Media Capabilities: implement Blink shell of encrypted media support.

This is adding the interface changes, the code checking for corectedness,
does type conversion and checks for the edge cases mentioned in spec.

This is also adding WPT.

Bug: 907909
Change-Id: Ieebe5b25202a403e50a09576ac283690c0f0ba55
Reviewed-on: https://chromium-review.googlesource.com/c/1348972
Commit-Queue: Mounir Lamouri <mlamouri@chromium.org>
Reviewed-by: Chrome Cunningham <chcunningham@chromium.org>
Reviewed-by: Philip Jägenstedt <foolip@chromium.org>
Cr-Commit-Position: refs/heads/master@{#611871}

third_party/blink/public/BUILD.gn

@@ -146,7 +146,9 @@ source_set("blink_headers") {
     "platform/modules/media_capabilities/web_media_capabilities_callbacks.h",
     "platform/modules/media_capabilities/web_media_capabilities_client.h",
     "platform/modules/media_capabilities/web_media_capabilities_info.h",
+    "platform/modules/media_capabilities/web_media_capabilities_key_system_configuration.h",
     "platform/modules/media_capabilities/web_media_configuration.h",
+    "platform/modules/media_capabilities/web_media_decoding_configuration.h",
     "platform/modules/media_capabilities/web_video_configuration.h",
     "platform/modules/notifications/web_notification_action.h",
     "platform/modules/notifications/web_notification_constants.h",

third_party/blink/public/platform/modules/media_capabilities/web_media_capabilities_key_system_configuration.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIA_CAPABILITIES_WEB_MEDIA_CAPABILITIES_KEY_SYSTEM_CONFIGURATION_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIA_CAPABILITIES_WEB_MEDIA_CAPABILITIES_KEY_SYSTEM_CONFIGURATION_H_
+
+#include "third_party/blink/public/platform/web_encrypted_media_types.h"
+#include "third_party/blink/public/platform/web_media_key_system_configuration.h"
+#include "third_party/blink/public/platform/web_vector.h"
+
+namespace blink {
+
+// Represents a MediaCapabilitiesKeySystemConfiguration dictionary to be used
+// outside of Blink. When possible, the properties will be converted from string
+// to Web types. The default values and behavior when invalid or missing is
+// specific to each property.
+struct WebMediaCapabilitiesKeySystemConfiguration {
+  // This property is mandatory and should always contain a value. However, it
+  // is not guaranteed that the value is valid.
+  WebString key_system;
+
+  // This is optional and will contain WebEncryptedMediaInitDataType::kUnknown
+  // if invalid or not present.
+  WebEncryptedMediaInitDataType init_data_type;
+
+  // Robustness properties are optional and will contain the empty string if not
+  // set. These values are not verified.
+  WebString audio_robustness = "";
+  WebString video_robustness = "";
+
+  // These two properties are optional and will be set to
+  // WebMediaKeySystemConfiguration::Requirement::kOptional if invalid or not
+  // present.
+  WebMediaKeySystemConfiguration::Requirement distinctive_identifier =
+      WebMediaKeySystemConfiguration::Requirement::kOptional;
+  WebMediaKeySystemConfiguration::Requirement persistent_state =
+      WebMediaKeySystemConfiguration::Requirement::kOptional;
+
+  // This is optional and will be an empty vector if not set. Each item in the
+  // vector will be parsed and will be set to
+  // WebEncryptedMediaSessionType::kUnknown if invalid.
+  WebVector<WebEncryptedMediaSessionType> session_types;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIA_CAPABILITIES_WEB_MEDIA_CAPABILITIES_KEY_SYSTEM_CONFIGURATION_H_

third_party/blink/public/platform/modules/media_capabilities/web_media_decoding_configuration.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIA_CAPABILITIES_WEB_MEDIA_DECODING_CONFIGURATION_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIA_CAPABILITIES_WEB_MEDIA_DECODING_CONFIGURATION_H_
+
+#include "base/optional.h"
+#include "third_party/blink/public/platform/modules/media_capabilities/web_media_capabilities_key_system_configuration.h"
+#include "third_party/blink/public/platform/modules/media_capabilities/web_media_configuration.h"
+
+namespace blink {
+
+// Represents a MediaDecodingConfiguration dictionary to be used outside of
+// Blink. The added `key_system_configuration` is optional and, if set, can be
+// assumed to match the requirements set by the specification.
+struct WebMediaDecodingConfiguration : public WebMediaConfiguration {
+  base::Optional<WebMediaCapabilitiesKeySystemConfiguration>
+      key_system_configuration;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIA_CAPABILITIES_WEB_MEDIA_DECODING_CONFIGURATION_H_

third_party/blink/renderer/modules/encryptedmedia/encrypted_media_utils.cc

@@ -115,4 +115,34 @@ String EncryptedMediaUtils::ConvertKeyStatusToString(
   return "internal-error";
 }
 
+// static
+WebMediaKeySystemConfiguration::Requirement
+EncryptedMediaUtils::ConvertToMediaKeysRequirement(const String& requirement) {
+  if (requirement == "required")
+    return WebMediaKeySystemConfiguration::Requirement::kRequired;
+  if (requirement == "optional")
+    return WebMediaKeySystemConfiguration::Requirement::kOptional;
+  if (requirement == "not-allowed")
+    return WebMediaKeySystemConfiguration::Requirement::kNotAllowed;
+
+  NOTREACHED();
+  return WebMediaKeySystemConfiguration::Requirement::kOptional;
+}
+
+// static
+String EncryptedMediaUtils::ConvertMediaKeysRequirementToString(
+    WebMediaKeySystemConfiguration::Requirement requirement) {
+  switch (requirement) {
+    case WebMediaKeySystemConfiguration::Requirement::kRequired:
+      return "required";
+    case WebMediaKeySystemConfiguration::Requirement::kOptional:
+      return "optional";
+    case WebMediaKeySystemConfiguration::Requirement::kNotAllowed:
+      return "not-allowed";
+  }
+
+  NOTREACHED();
+  return "not-allowed";
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/encryptedmedia/encrypted_media_utils.h

@@ -7,6 +7,7 @@
 
 #include "third_party/blink/public/platform/web_encrypted_media_key_information.h"
 #include "third_party/blink/public/platform/web_encrypted_media_types.h"
+#include "third_party/blink/public/platform/web_media_key_system_configuration.h"
 #include "third_party/blink/renderer/platform/wtf/allocator.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 
@@ -26,6 +27,11 @@ class EncryptedMediaUtils {
 
   static String ConvertKeyStatusToString(
       const WebEncryptedMediaKeyInformation::KeyStatus);
+
+  static WebMediaKeySystemConfiguration::Requirement
+  ConvertToMediaKeysRequirement(const String&);
+  static String ConvertMediaKeysRequirementToString(
+      WebMediaKeySystemConfiguration::Requirement);
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/encryptedmedia/media_key_system_access.cc

@@ -105,21 +105,6 @@ static HeapVector<Member<MediaKeySystemMediaCapability>> ConvertCapabilities(
   return result;
 }
 
-static String ConvertMediaKeysRequirement(
-    WebMediaKeySystemConfiguration::Requirement requirement) {
-  switch (requirement) {
-    case WebMediaKeySystemConfiguration::Requirement::kRequired:
-      return "required";
-    case WebMediaKeySystemConfiguration::Requirement::kOptional:
-      return "optional";
-    case WebMediaKeySystemConfiguration::Requirement::kNotAllowed:
-      return "not-allowed";
-  }
-
-  NOTREACHED();
-  return "not-allowed";
-}
-
 static Vector<String> ConvertSessionTypes(
     const WebVector<WebEncryptedMediaSessionType>& session_types) {
   Vector<String> result(SafeCast<wtf_size_t>(session_types.size()));
@@ -154,9 +139,11 @@ MediaKeySystemConfiguration* MediaKeySystemAccess::getConfiguration() const {
   // |distinctiveIdentifier|, |persistentState|, and |sessionTypes| are always
   // set by requestMediaKeySystemAccess().
   result->setDistinctiveIdentifier(
-      ConvertMediaKeysRequirement(configuration.distinctive_identifier));
+      EncryptedMediaUtils::ConvertMediaKeysRequirementToString(
+          configuration.distinctive_identifier));
   result->setPersistentState(
-      ConvertMediaKeysRequirement(configuration.persistent_state));
+      EncryptedMediaUtils::ConvertMediaKeysRequirementToString(
+          configuration.persistent_state));
   result->setSessionTypes(ConvertSessionTypes(configuration.session_types));
 
   // |label| will (and should) be a null string if it was not set.

third_party/blink/renderer/modules/encryptedmedia/navigator_request_media_key_system_access.cc

@@ -98,20 +98,6 @@ static WebVector<WebMediaKeySystemMediaCapability> ConvertCapabilities(
   return result;
 }
 
-static WebMediaKeySystemConfiguration::Requirement ConvertMediaKeysRequirement(
-    const String& requirement) {
-  if (requirement == "required")
-    return WebMediaKeySystemConfiguration::Requirement::kRequired;
-  if (requirement == "optional")
-    return WebMediaKeySystemConfiguration::Requirement::kOptional;
-  if (requirement == "not-allowed")
-    return WebMediaKeySystemConfiguration::Requirement::kNotAllowed;
-
-  // Everything else gets the default value.
-  NOTREACHED();
-  return WebMediaKeySystemConfiguration::Requirement::kOptional;
-}
-
 static WebVector<WebEncryptedMediaSessionType> ConvertSessionTypes(
     const Vector<String>& session_types) {
   WebVector<WebEncryptedMediaSessionType> result(session_types.size());
@@ -189,11 +175,13 @@ MediaKeySystemAccessInitializer::MediaKeySystemAccessInitializer(
 
     DCHECK(config->hasDistinctiveIdentifier());
     web_config.distinctive_identifier =
-        ConvertMediaKeysRequirement(config->distinctiveIdentifier());
+        EncryptedMediaUtils::ConvertToMediaKeysRequirement(
+            config->distinctiveIdentifier());
 
     DCHECK(config->hasPersistentState());
     web_config.persistent_state =
-        ConvertMediaKeysRequirement(config->persistentState());
+        EncryptedMediaUtils::ConvertToMediaKeysRequirement(
+            config->persistentState());
 
     if (config->hasSessionTypes()) {
       web_config.session_types = ConvertSessionTypes(config->sessionTypes());

third_party/blink/renderer/modules/media_capabilities/DEPS

 include_rules = [
     "-third_party/blink/renderer/modules",
+    "+third_party/blink/renderer/modules/encryptedmedia",
     "+third_party/blink/renderer/modules/media_capabilities",
 ]

third_party/blink/renderer/modules/media_capabilities/media_capabilities.cc

@@ -9,6 +9,7 @@
 #include "third_party/blink/public/platform/modules/media_capabilities/web_media_capabilities_client.h"
 #include "third_party/blink/public/platform/modules/media_capabilities/web_media_capabilities_info.h"
 #include "third_party/blink/public/platform/modules/media_capabilities/web_media_configuration.h"
+#include "third_party/blink/public/platform/modules/media_capabilities/web_media_decoding_configuration.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/public/platform/web_media_recorder_handler.h"
@@ -16,6 +17,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/core/html/parser/html_parser_idioms.h"
+#include "third_party/blink/renderer/modules/encryptedmedia/encrypted_media_utils.h"
 #include "third_party/blink/renderer/modules/media_capabilities/media_capabilities_decoding_info_callbacks.h"
 #include "third_party/blink/renderer/modules/media_capabilities/media_capabilities_encoding_info_callbacks.h"
 #include "third_party/blink/renderer/modules/media_capabilities/media_capabilities_info.h"
@@ -85,6 +87,39 @@ bool IsValidMediaConfiguration(const MediaConfiguration* configuration) {
   return configuration->hasAudio() || configuration->hasVideo();
 }
 
+bool IsValidMediaDecodingConfiguration(
+    const MediaDecodingConfiguration* configuration,
+    String* message) {
+  if (!IsValidMediaConfiguration(configuration)) {
+    *message =
+        "The configuration dictionary has neither |video| nor |audio| "
+        "specified and needs at least one of them.";
+    return false;
+  }
+
+  if (configuration->hasKeySystemConfiguration()) {
+    if (configuration->keySystemConfiguration()->hasAudioRobustness() &&
+        !configuration->hasAudio()) {
+      *message =
+          "The keySystemConfiguration object contains an "
+          "audioRobustness property but the root configuration has no "
+          "audio configuration.";
+      return false;
+    }
+
+    if (configuration->keySystemConfiguration()->hasVideoRobustness() &&
+        !configuration->hasVideo()) {
+      *message =
+          "The keySystemConfiguration object contains an "
+          "videoRobustness property but the root configuration has no "
+          "video configuration.";
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool IsValidVideoConfiguration(const VideoConfiguration* configuration) {
   DCHECK(configuration->hasContentType());
 
@@ -166,9 +201,54 @@ WebVideoConfiguration ToWebVideoConfiguration(
   return web_configuration;
 }
 
-WebMediaConfiguration ToWebMediaConfiguration(
+WebMediaCapabilitiesKeySystemConfiguration
+ToWebMediaCapabilitiesKeySystemConfiguration(
+    const MediaCapabilitiesKeySystemConfiguration* configuration) {
+  WebMediaCapabilitiesKeySystemConfiguration web_configuration;
+
+  // |keySystem| is mandatory.
+  DCHECK(configuration->hasKeySystem());
+  web_configuration.key_system = configuration->keySystem();
+
+  if (configuration->hasInitDataType()) {
+    web_configuration.init_data_type =
+        EncryptedMediaUtils::ConvertToInitDataType(
+            configuration->initDataType());
+  }
+
+  // |audio_robustness| and |video_robustess| have a default value.
+  if (configuration->hasAudioRobustness())
+    web_configuration.audio_robustness = configuration->audioRobustness();
+  if (configuration->hasVideoRobustness())
+    web_configuration.video_robustness = configuration->videoRobustness();
+
+  // |distinctive_identifier| and |persistent_state| have a default value so
+  // they should only be set if needed.
+  if (configuration->hasDistinctiveIdentifier()) {
+    web_configuration.distinctive_identifier =
+        EncryptedMediaUtils::ConvertToMediaKeysRequirement(
+            configuration->distinctiveIdentifier());
+  }
+  if (configuration->hasPersistentState()) {
+    web_configuration.persistent_state =
+        EncryptedMediaUtils::ConvertToMediaKeysRequirement(
+            configuration->persistentState());
+  }
+
+  // |session_types| has a default value because it is a WebVector.
+  if (configuration->hasSessionTypes()) {
+    for (const String& session_type : configuration->sessionTypes()) {
+      web_configuration.session_types.emplace_back(
+          EncryptedMediaUtils::ConvertToSessionType(session_type));
+    }
+  }
+
+  return web_configuration;
+}
+
+WebMediaDecodingConfiguration ToWebMediaConfiguration(
     const MediaDecodingConfiguration* configuration) {
-  WebMediaConfiguration web_configuration;
+  WebMediaDecodingConfiguration web_configuration;
 
   // |type| is mandatory.
   DCHECK(configuration->hasType());
@@ -189,6 +269,12 @@ WebMediaConfiguration ToWebMediaConfiguration(
         ToWebVideoConfiguration(configuration->video());
   }
 
+  if (configuration->hasKeySystemConfiguration()) {
+    web_configuration.key_system_configuration =
+        ToWebMediaCapabilitiesKeySystemConfiguration(
+            configuration->keySystemConfiguration());
+  }
+
   return web_configuration;
 }
 
@@ -221,11 +307,10 @@ ScriptPromise MediaCapabilities::decodingInfo(
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
-  if (!IsValidMediaConfiguration(configuration)) {
-    resolver->Reject(V8ThrowException::CreateTypeError(
-        script_state->GetIsolate(),
-        "The configuration dictionary has neither |video| nor |audio| "
-        "specified and needs at least one of them."));
+  String error;
+  if (!IsValidMediaDecodingConfiguration(configuration, &error)) {
+    resolver->Reject(
+        V8ThrowException::CreateTypeError(script_state->GetIsolate(), error));
     return promise;
   }
 
@@ -245,6 +330,25 @@ ScriptPromise MediaCapabilities::decodingInfo(
     return promise;
   }
 
+  if (configuration->hasKeySystemConfiguration()) {
+    ExecutionContext* execution_context = ExecutionContext::From(script_state);
+    DCHECK(execution_context);
+    if (execution_context->IsWorkerGlobalScope()) {
+      resolver->Reject(DOMException::Create(
+          DOMExceptionCode::kInvalidStateError,
+          "Encrypted Media decoding info not available in Worker context."));
+      return promise;
+    }
+
+    if (!execution_context->IsSecureContext()) {
+      resolver->Reject(
+          DOMException::Create(DOMExceptionCode::kSecurityError,
+                               "Encrypted Media decoding info can only be "
+                               "queried in a secure context."));
+      return promise;
+    }
+  }
+
   Platform::Current()->MediaCapabilitiesClient()->DecodingInfo(
       ToWebMediaConfiguration(configuration),
       std::make_unique<MediaCapabilitiesDecodingInfoCallbacks>(resolver));

third_party/blink/renderer/modules/media_capabilities/media_capabilities.idl

@@ -6,7 +6,7 @@
 
 [Exposed=Window]
 interface MediaCapabilities {
-    [CallWith=ScriptState, Measure] Promise<MediaCapabilitiesInfo> decodingInfo(MediaDecodingConfiguration configuration);
+    [CallWith=ScriptState, Measure] Promise<MediaCapabilitiesDecodingInfo> decodingInfo(MediaDecodingConfiguration configuration);
     [CallWith=ScriptState, Measure, RuntimeEnabled=MediaCapabilitiesEncodingInfo] Promise<MediaCapabilitiesInfo> encodingInfo(
         MediaEncodingConfiguration configuration);
 };

third_party/blink/renderer/modules/media_capabilities/media_capabilities_decoding_info.idl

+// Copyright 2017 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.
+
+// https://wicg.github.io/media-capabilities/#dictdef-mediacapabilitiesdecodinginfo
+
+dictionary MediaCapabilitiesDecodingInfo : MediaCapabilitiesInfo {
+    [RuntimeEnabled=MediaCapabilitiesEncryptedMedia] MediaKeySystemAccess? keySystemAccess = null;
+};

third_party/blink/renderer/modules/media_capabilities/media_capabilities_decoding_info_callbacks.cc

@@ -4,7 +4,7 @@
 
 #include "third_party/blink/renderer/modules/media_capabilities/media_capabilities_decoding_info_callbacks.h"
 
-#include "third_party/blink/renderer/modules/media_capabilities/media_capabilities_info.h"
+#include "third_party/blink/renderer/modules/media_capabilities/media_capabilities_decoding_info.h"
 
 namespace blink {
 
@@ -22,7 +22,8 @@ void MediaCapabilitiesDecodingInfoCallbacks::OnSuccess(
     return;
   }
 
-  Persistent<MediaCapabilitiesInfo> info(MediaCapabilitiesInfo::Create());
+  Persistent<MediaCapabilitiesDecodingInfo> info(
+      MediaCapabilitiesDecodingInfo::Create());
   info->setSupported(result->supported);
   info->setSmooth(result->smooth);
   info->setPowerEfficient(result->power_efficient);

third_party/blink/renderer/modules/media_capabilities/media_capabilities_key_system_configuration.idl

+// Copyright 2018 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.
+
+// https://wicg.github.io/media-capabilities/#dictdef-mediacapabilitieskeysystemconfiguration
+
+dictionary MediaCapabilitiesKeySystemConfiguration {
+    required DOMString keySystem;
+    DOMString initDataType = "";
+    DOMString audioRobustness;
+    DOMString videoRobustness;
+    MediaKeysRequirement distinctiveIdentifier = "optional";
+    MediaKeysRequirement persistentState = "optional";
+    sequence<DOMString> sessionTypes;
+};

third_party/blink/renderer/modules/media_capabilities/media_decoding_configuration.idl

@@ -13,4 +13,5 @@ enum MediaDecodingType {
 
 dictionary MediaDecodingConfiguration : MediaConfiguration {
     required MediaDecodingType type;
+    [RuntimeEnabled=MediaCapabilitiesEncryptedMedia] MediaCapabilitiesKeySystemConfiguration keySystemConfiguration;
 };

third_party/blink/renderer/modules/modules_idl_files.gni

@@ -559,7 +559,9 @@ modules_dictionary_idl_files =
           "manifest/image_resource.idl",
           "media_capabilities/audio_configuration.idl",
           "media_capabilities/media_configuration.idl",
+          "media_capabilities/media_capabilities_decoding_info.idl",
           "media_capabilities/media_capabilities_info.idl",
+          "media_capabilities/media_capabilities_key_system_configuration.idl",
           "media_capabilities/media_decoding_configuration.idl",
           "media_capabilities/media_encoding_configuration.idl",
           "media_capabilities/video_configuration.idl",

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -724,6 +724,10 @@
       name: "MediaCapabilitiesEncodingInfo",
       status: "experimental",
     },
+    {
+      name: "MediaCapabilitiesEncryptedMedia",
+      status: "experimental",
+    },
     {
       name: "MediaCapture",
     },

third_party/blink/web_tests/external/wpt/media-capabilities/decodingInfo.html

@@ -286,6 +286,7 @@ promise_test(t => {
     assert_equals(typeof ability.supported, "boolean");
     assert_equals(typeof ability.smooth, "boolean");
     assert_equals(typeof ability.powerEfficient, "boolean");
+    assert_equals(typeof ability.keySystemAccess, "object");
   });
 }, "Test that decodingInfo returns a valid MediaCapabilitiesInfo objects");
 

third_party/blink/web_tests/external/wpt/media-capabilities/decodingInfoEncryptedMedia.http.html

+<!DOCTYPE html>
+<title>MediaCapabilities.decodingInfo() for encrypted media (non-secure context)</title>
+<script src=/resources/testharness.js></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+// Minimal VideoConfiguration that will be allowed per spec. All optional
+// properties are missing.
+var minimalVideoConfiguration = {
+  contentType: 'video/webm; codecs="vp09.00.10.08"',
+  width: 800,
+  height: 600,
+  bitrate: 3000,
+  framerate: 24,
+};
+
+// Minimal MediaCapabilitiesKeySystemConfiguration that will be allowed per
+// spec. All optional properties are missing.
+var minimalKeySystemConfiguration = {
+  keySystem: 'org.w3.clearkey'
+};
+
+promise_test(t => {
+  return promise_rejects(t, 'SecurityError', navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: minimalKeySystemConfiguration,
+  }));
+}, "Test that decodingInfo() with a keySystemConfiguration fails on a non-secure context.");
+
+</script>

third_party/blink/web_tests/external/wpt/media-capabilities/decodingInfoEncryptedMedia.https.html

+<!DOCTYPE html>
+<title>MediaCapabilities.decodingInfo() for encrypted media</title>
+<script src=/resources/testharness.js></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+// Minimal VideoConfiguration that will be allowed per spec. All optional
+// properties are missing.
+var minimalVideoConfiguration = {
+  contentType: 'video/webm; codecs="vp09.00.10.08"',
+  width: 800,
+  height: 600,
+  bitrate: 3000,
+  framerate: 24,
+};
+
+// Minimal AudioConfiguration that will be allowed per spec. All optional
+// properties are missing.
+var minimalAudioConfiguration = {
+  contentType: 'audio/webm; codecs="opus"',
+};
+
+// Minimal MediaCapabilitiesKeySystemConfiguration that will be allowed per
+// spec. All optional properties are missing.
+var minimalKeySystemConfiguration = {
+  keySystem: 'org.w3.clearkey',
+};
+
+promise_test(t => {
+  return navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: minimalKeySystemConfiguration,
+  });
+}, "Test that decodingInfo() accepts a stub key system configuration (w/video).");
+
+promise_test(t => {
+  return navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    keySystemConfiguration: minimalKeySystemConfiguration,
+  });
+}, "Test that decodingInfo() accepts a stub key system configuration (w/audio).");
+
+promise_test(t => {
+  return navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      videoRobustness: '',
+    },
+  });
+}, "Test that decodingInfo() accepts a key system configuration with video info.");
+
+promise_test(t => {
+  return navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      audioRobustness: '',
+    },
+  });
+}, "Test that decodingInfo() accepts a key system configuration with audio info.");
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      videoRobustness: '',
+    },
+  }));
+}, "Test that decodingInfo() rejects if robustness and configuration do not match (1).");
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      audioRobustness: '',
+    },
+  }));
+}, "Test that decodingInfo() rejects if robustness and configuration do not match (2).");
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      audioRobustness: '',
+      videoRobustness: '',
+    },
+  }));
+}, "Test that decodingInfo() rejects if robustness and configuration do not match (3).");
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      audioRobustness: '',
+      videoRobustness: '',
+      persistentState: "foobar",
+    },
+  }));
+}, "Test that decodingInfo() rejects if persistentState isn't valid.");
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      audioRobustness: '',
+      videoRobustness: '',
+      distinctiveIdentifier: "foobar",
+    },
+  }));
+}, "Test that decodingInfo() rejects if distinctiveIdentifier isn't valid.");
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: 'org.w3.clearkey',
+      audioRobustness: '',
+      videoRobustness: '',
+      sessionTypes: "foobar",
+    },
+  }));
+}, "Test that decodingInfo() rejects if sessionTypes isn't a sequence.");
+
+promise_test(t => {
+  return navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    audio: minimalAudioConfiguration,
+    video: minimalVideoConfiguration,
+    keySystemConfiguration: {
+      keySystem: {},
+      initDataType: {},
+      audioRobustness: {},
+      videoRobustness: {},
+    },
+  });
+}, "Test that decodingInfo() does not reject when properties are set to unexpected values.");
+
+promise_test(t => {
+  return navigator.mediaCapabilities.decodingInfo({
+    type: 'file',
+    video: minimalVideoConfiguration,
+    audio: minimalAudioConfiguration,
+    keySystemConfiguration: minimalKeySystemConfiguration,
+  }).then(ability => {
+    assert_equals(typeof ability.supported, "boolean");
+    assert_equals(typeof ability.smooth, "boolean");
+    assert_equals(typeof ability.powerEfficient, "boolean");
+    assert_equals(typeof ability.keySystemAccess, "object");
+  });
+}, "Test that decodingInfo returns a valid MediaCapabilitiesDecodingInfo objects with encrypted media");
+
+</script>