EME: Require codecs parameter for audio/videoCapabilities

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 <algorithm>
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 67 matching lines @@
 }
 
 static WebVector<WebEncryptedMediaSessionType> convertSessionTypes(
     const Vector<String>& sessionTypes) {
   WebVector<WebEncryptedMediaSessionType> result(sessionTypes.size());
   for (size_t i = 0; i < sessionTypes.size(); ++i)
     result[i] = EncryptedMediaUtils::convertToSessionType(sessionTypes[i]);
   return result;
 }
 
-static bool AreCodecsSpecified(
-    const WebMediaKeySystemMediaCapability& capability) {
-  return !capability.codecs.isEmpty();
-}
-
 // This class allows capabilities to be checked and a MediaKeySystemAccess
 // object to be created asynchronously.
 class MediaKeySystemAccessInitializer final : public EncryptedMediaRequest {
   WTF_MAKE_NONCOPYABLE(MediaKeySystemAccessInitializer);
 
  public:
   MediaKeySystemAccessInitializer(
       ScriptState*,
       const String& keySystem,
       const HeapVector<MediaKeySystemConfiguration>& supportedConfigurations);
@@ skipping 18 matching lines @@
 
  private:
   // Returns true if the ExecutionContext is valid, false otherwise.
   bool isExecutionContextValid() const;
 
   // For widevine key system, generate warning and report to UMA if
   // |m_supportedConfigurations| contains any video capability with empty
   // robustness string.
   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&);
-
   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)),
@@ skipping 45 matching lines @@
 }
 
 SecurityOrigin* MediaKeySystemAccessInitializer::getSecurityOrigin() const {
   return isExecutionContextValid()
              ? m_resolver->getExecutionContext()->getSecurityOrigin()
              : nullptr;
 }
 
 void MediaKeySystemAccessInitializer::requestSucceeded(
     WebContentDecryptionModuleAccess* access) {
-  checkEmptyCodecs(access->getConfiguration());
-
   if (!isExecutionContextValid())
     return;
 
   m_resolver->resolve(
       new MediaKeySystemAccess(m_keySystem, WTF::wrapUnique(access)));
   m_resolver.clear();
 }
 
 void MediaKeySystemAccessInitializer::requestNotSupported(
     const WebString& errorMessage) {
@@ skipping 43 matching lines @@
 
   if (hasEmptyRobustness) {
     m_resolver->getExecutionContext()->addConsoleMessage(ConsoleMessage::create(
         JSMessageSource, WarningMessageLevel,
         "It is recommended that a robustness level be specified. Not "
         "specifying the robustness level could result in unexpected behavior, "
         "potentially including failure to play."));
   }
 }
 
-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.audioCapabilities.isEmpty()) {
-    areAllAudioCodecsEmpty =
-        std::find_if(config.audioCapabilities.begin(),
-                     config.audioCapabilities.end(),
-                     AreCodecsSpecified) == config.audioCapabilities.end();
-  }
-
-  bool areAllVideoCodecsEmpty = false;
-  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);
-  }
-}
-
 }  // namespace
 
 ScriptPromise NavigatorRequestMediaKeySystemAccess::requestMediaKeySystemAccess(
     ScriptState* scriptState,
     Navigator& navigator,
     const String& keySystem,
     const HeapVector<MediaKeySystemConfiguration>& supportedConfigurations) {
   DVLOG(3) << __func__;
 
   ExecutionContext* executionContext = scriptState->getExecutionContext();
@@ skipping 65 matching lines @@
   WebEncryptedMediaClient* mediaClient =
       controller->encryptedMediaClient(executionContext);
   mediaClient->requestMediaKeySystemAccess(
       WebEncryptedMediaRequest(initializer));
 
   // 7. Return promise.
   return promise;
 }
 
 }  // namespace blink