EME: Fail requestMediaKeySystemAccess if no capabilities specified

media/blink/key_system_config_selector_unittest.cc

 // Copyright 2015 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 11 matching lines @@
 
 namespace media {
 
 namespace {
 
 const char kSupported[] = "supported";
 const char kRecommendIdentifier[] = "recommend_identifier";
 const char kRequireIdentifier[] = "require_identifier";
 const char kUnsupported[] = "unsupported";
 
-// TODO(sandersd): Audio and video variants (doesn't matter for now because the
-// checks are in KeySystems).
-const char kSupportedContainer[] = "video/webm";
+const char kSupportedVideoContainer[] = "video/webm";
+const char kSupportedAudioContainer[] = "audio/webm";
 const char kUnsupportedContainer[] = "video/foo";
 
 // TODO(sandersd): Extended codec variants (requires proprietary codec support).
-const char kSupportedCodec[] = "vp8";
+const char kSupportedVideoCodec[] = "vp8";
+const char kSupportedAudioCodec[] = "opus";
 const char kUnsupportedCodec[] = "foo";
 const char kUnsupportedCodecs[] = "vp8,foo";
-const char kSupportedCodecs[] = "vp8,vp8";
+const char kSupportedVideoCodecs[] = "vp8,vp8";
 
 const char kDefaultSecurityOrigin[] = "https://example.com/";
 
 // The IDL for MediaKeySystemConfiguration specifies some defaults, so
 // create a default object that mimics what would be created if an empty
 // dictionary was passed in.

[xhwang, 2017/02/02 18:31:20]

Is this still accurate with the new changes?

[jrummell, 2017/02/02 20:03:24]

Nope. Added UsableConfiguration().

 blink::WebMediaKeySystemConfiguration DefaultConfiguration() {
   // http://w3c.github.io/encrypted-media/#mediakeysystemconfiguration-dictionary
   // If this member (sessionTypes) is not present when the dictionary
   // is passed to requestMediaKeySystemAccess(), the dictionary will
   // be treated as if this member is set to [ "temporary" ].
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
 
+  // EME spec requires that at least one of |video_capabilities| and
+  // |audio_capabilities| be specified. Add a single valid audio capability
+  // here. blink code parses the contentType into mimeType and codecs, so
+  // mimic that here.
+  std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(1);
+  audio_capabilities[0].mimeType = kSupportedAudioContainer;
+  audio_capabilities[0].codecs = kSupportedAudioCodec;
+
   blink::WebMediaKeySystemConfiguration config;
   config.label = "";
   config.sessionTypes = session_types;
+  config.audioCapabilities = audio_capabilities;
   return config;
 }
 
 class FakeKeySystems : public KeySystems {
  public:
   ~FakeKeySystems() override {
   }
 
   bool IsSupportedKeySystem(const std::string& key_system) const override {
     if (key_system == kSupported)
@@ skipping 19 matching lines @@
   }
 
   // TODO(sandersd): Secure codec simulation.
   EmeConfigRule GetContentTypeConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& container_mime_type,
       const std::vector<std::string>& codecs) const override {
     if (container_mime_type == kUnsupportedContainer)
       return EmeConfigRule::NOT_SUPPORTED;
-    DCHECK_EQ(kSupportedContainer, container_mime_type);
+    switch (media_type) {
+      case EmeMediaType::AUDIO:
+        DCHECK_EQ(kSupportedAudioContainer, container_mime_type);
+        break;
+      case EmeMediaType::VIDEO:
+        DCHECK_EQ(kSupportedVideoContainer, container_mime_type);
+        break;
+    }
     for (const std::string& codec : codecs) {
       if (codec == kUnsupportedCodec)
         return EmeConfigRule::NOT_SUPPORTED;
-      DCHECK_EQ(kSupportedCodec, codec);
+      switch (media_type) {
+        case EmeMediaType::AUDIO:
+          DCHECK_EQ(kSupportedAudioCodec, codec);
+          break;
+        case EmeMediaType::VIDEO:
+          DCHECK_EQ(kSupportedVideoCodec, codec);
+          break;
+      }
     }
     return EmeConfigRule::SUPPORTED;
   }
 
   EmeConfigRule GetRobustnessConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& requested_robustness) const override {
     if (requested_robustness.empty())
       return EmeConfigRule::SUPPORTED;
@@ skipping 153 matching lines @@
 TEST_F(KeySystemConfigSelectorTest, DefaultConfig) {
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
 
   // label = "";
   ASSERT_EQ("", config.label);
 
   // initDataTypes = [];
   ASSERT_EQ(0u, config.initDataTypes.size());
 
   // audioCapabilities = [];
-  ASSERT_EQ(0u, config.audioCapabilities.size());
+  ASSERT_EQ(1u, config.audioCapabilities.size());
 
   // videoCapabilities = [];
   ASSERT_EQ(0u, config.videoCapabilities.size());
 
   // distinctiveIdentifier = "optional";
   ASSERT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Optional,
             config.distinctiveIdentifier);
 
   // persistentState = "optional";
   ASSERT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Optional,
             config.persistentState);
 
   // 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" ].
   ASSERT_EQ(1u, config.sessionTypes.size());
   ASSERT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
             config.sessionTypes[0]);
 }
 
 // Most of the tests below assume that the default config is valid.
 TEST_F(KeySystemConfigSelectorTest, EmptyConfig) {
   configs_.push_back(DefaultConfiguration());
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ("", config_.label);
   EXPECT_TRUE(config_.initDataTypes.isEmpty());
-  EXPECT_TRUE(config_.audioCapabilities.isEmpty());
+  EXPECT_EQ(1u, config_.audioCapabilities.size());

[xhwang, 2017/02/02 18:31:20]

The test is called EmptyConfig. Is it still accurate?

Also, do we have a test that both audio and video capabilities are empty?

[jrummell, 2017/02/02 20:03:24]

Updated the test to make sure EmptyConfig fails, and added new test to verify
the DefaultConfig.

   EXPECT_TRUE(config_.videoCapabilities.isEmpty());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.distinctiveIdentifier);
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.persistentState);
   ASSERT_EQ(1u, config_.sessionTypes.size());
   EXPECT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
             config_.sessionTypes[0]);
 }
 
@@ skipping 256 matching lines @@
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_NoneSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kUnsupportedContainer;
   video_capabilities[1].contentType = "b";
-  video_capabilities[1].mimeType = kSupportedContainer;
+  video_capabilities[1].mimeType = kSupportedVideoContainer;
   video_capabilities[1].codecs = kUnsupportedCodec;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kUnsupportedContainer;
   video_capabilities[1].contentType = "b";
-  video_capabilities[1].mimeType = kSupportedContainer;
+  video_capabilities[1].mimeType = kSupportedVideoContainer;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_EQ("b", config_.videoCapabilities[0].contentType);
-  EXPECT_EQ(kSupportedContainer, config_.videoCapabilities[0].mimeType);
+  EXPECT_EQ(kSupportedVideoContainer, config_.videoCapabilities[0].mimeType);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_AllSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[1].contentType = "b";
-  video_capabilities[1].mimeType = kSupportedContainer;
-  video_capabilities[1].codecs = kSupportedCodecs;
+  video_capabilities[1].mimeType = kSupportedVideoContainer;
+  video_capabilities[1].codecs = kSupportedVideoCodecs;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(2u, config_.videoCapabilities.size());
   EXPECT_EQ("a", config_.videoCapabilities[0].contentType);
   EXPECT_EQ("b", config_.videoCapabilities[1].contentType);
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        VideoCapabilities_Codecs_SubsetSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].codecs = kUnsupportedCodecs;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Codecs_AllSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
-  video_capabilities[0].codecs = kSupportedCodecs;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodecs;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
-  EXPECT_EQ(kSupportedCodecs, config_.videoCapabilities[0].codecs);
+  EXPECT_EQ(kSupportedVideoCodecs, config_.videoCapabilities[0].codecs);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Empty) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   ASSERT_TRUE(video_capabilities[0].robustness.isEmpty());
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_TRUE(config_.videoCapabilities[0].robustness.isEmpty());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Supported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kSupported;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_EQ(kSupported, config_.videoCapabilities[0].robustness);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Unsupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kUnsupported;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        VideoCapabilities_Robustness_PermissionCanBeRequired) {
   media_permission_->is_granted = true;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kRequireIdentifier;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.distinctiveIdentifier);
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        VideoCapabilities_Robustness_PermissionCanBeRecommended) {
   media_permission_->is_granted = false;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kRecommendIdentifier;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.distinctiveIdentifier);
 }
 
 // --- audioCapabilities ---
 // These are handled by the same code as |videoCapabilities|, so only minimal
 // additional testing is done.
 
 TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(2);
   audio_capabilities[0].contentType = "a";
   audio_capabilities[0].mimeType = kUnsupportedContainer;
   audio_capabilities[1].contentType = "b";
-  audio_capabilities[1].mimeType = kSupportedContainer;
+  audio_capabilities[1].mimeType = kSupportedAudioContainer;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.audioCapabilities = audio_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.audioCapabilities.size());
   EXPECT_EQ("b", config_.audioCapabilities[0].contentType);
-  EXPECT_EQ(kSupportedContainer, config_.audioCapabilities[0].mimeType);
+  EXPECT_EQ(kSupportedAudioContainer, config_.audioCapabilities[0].mimeType);
 }
 
 // --- Multiple configurations ---
 
 TEST_F(KeySystemConfigSelectorTest, Configurations_AllSupported) {
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.label = "a";
   configs_.push_back(config);
   config.label = "b";
   configs_.push_back(config);
@@ skipping 50 matching lines @@
 
   blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
   config2.label = "b";
   configs_.push_back(config2);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   ASSERT_EQ("b", config_.label);
 }
 
 }  // namespace media