Replace MediaKeySystemOptions with MediaKeySystemConfiguration.

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 "config.h"
 #include "modules/encryptedmedia/NavigatorRequestMediaKeySystemAccess.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
@@ skipping 14 matching lines @@
     String codecs = type.parameter("codecs");
     return blink::MIMETypeRegistry::isSupportedEncryptedMediaMIMEType(keySystem, type.type(), codecs);
 }
 
 // This class allows capabilities to be checked and a MediaKeySystemAccess
 // object to be created asynchronously.
 class MediaKeySystemAccessInitializer final : public blink::ScriptPromiseResolver {
     WTF_MAKE_NONCOPYABLE(MediaKeySystemAccessInitializer);
 
 public:
-    static blink::ScriptPromise create(blink::ScriptState*, const String& keySystem, const Vector<blink::MediaKeySystemOptions>& supportedConfigurations);
+    static blink::ScriptPromise create(blink::ScriptState*, const String& keySystem, const Vector<blink::MediaKeySystemConfiguration>& supportedConfigurations);
     virtual ~MediaKeySystemAccessInitializer();
 
 private:
-    MediaKeySystemAccessInitializer(blink::ScriptState*, const String& keySystem, const Vector<blink::MediaKeySystemOptions>& supportedConfigurations);
+    MediaKeySystemAccessInitializer(blink::ScriptState*, const String& keySystem, const Vector<blink::MediaKeySystemConfiguration>& supportedConfigurations);
     void timerFired(blink::Timer<MediaKeySystemAccessInitializer>*);
 
     const String m_keySystem;
-    const Vector<blink::MediaKeySystemOptions> m_supportedConfigurations;
+    const Vector<blink::MediaKeySystemConfiguration> m_supportedConfigurations;
     blink::Timer<MediaKeySystemAccessInitializer> m_timer;
 };
 
-blink::ScriptPromise MediaKeySystemAccessInitializer::create(blink::ScriptState* scriptState, const String& keySystem, const Vector<blink::MediaKeySystemOptions>& supportedConfigurations)
+blink::ScriptPromise MediaKeySystemAccessInitializer::create(blink::ScriptState* scriptState, const String& keySystem, const Vector<blink::MediaKeySystemConfiguration>& supportedConfigurations)
 {
     RefPtr<MediaKeySystemAccessInitializer> initializer = adoptRef(new MediaKeySystemAccessInitializer(scriptState, keySystem, supportedConfigurations));
     initializer->suspendIfNeeded();
     initializer->keepAliveWhilePending();
     return initializer->promise();
 }
 
-MediaKeySystemAccessInitializer::MediaKeySystemAccessInitializer(blink::ScriptState* scriptState, const String& keySystem, const Vector<blink::MediaKeySystemOptions>& supportedConfigurations)
+MediaKeySystemAccessInitializer::MediaKeySystemAccessInitializer(blink::ScriptState* scriptState, const String& keySystem, const Vector<blink::MediaKeySystemConfiguration>& supportedConfigurations)
     : blink::ScriptPromiseResolver(scriptState)
     , m_keySystem(keySystem)
     , m_supportedConfigurations(supportedConfigurations)
     , m_timer(this, &MediaKeySystemAccessInitializer::timerFired)
 {
     // Start the timer so that MediaKeySystemAccess can be created
     // asynchronously.
     // FIXME: If creating MediaKeySystemAccess or
     // isKeySystemSupportedWithContentType() is replaced with something
     // asynchronous, wait for the event rather than using a timer.
@@ skipping 31 matching lines @@
     for (const auto& combination : m_supportedConfigurations) {
         // 5.3.2.1 If the member's value cannot be satisfied together in
         //         combination with the previous members, continue to the next
         //         iteration of the loop.
         // 5.3.3 If keySystem is supported and allowed in the origin of the
         //       calling context's Document in the configuration specified by
         //       the combination of the values in combination, execute the
         //       following steps:
         // FIXME: This test needs to be enhanced to use more values from
         //        combination.
-        if (isKeySystemSupportedWithContentType(m_keySystem, combination.initDataType())) {
-            // 5.3.3.1 Let access be a new MediaKeySystemAccess object, and
-            //         initialize it as follows:
-            // 5.3.3.1.1 Set the keySystem attribute to keySystem.
-            blink::MediaKeySystemAccess* access = new blink::MediaKeySystemAccess(m_keySystem);
+        for (const auto& initDataType : combination.initDataTypes()) {
+            if (isKeySystemSupportedWithContentType(m_keySystem, initDataType)) {
+                // 5.3.3.1 Let access be a new MediaKeySystemAccess object, and
+                //         initialize it as follows:
+                // 5.3.3.1.1 Set the keySystem attribute to keySystem.
+                blink::MediaKeySystemAccess* access = new blink::MediaKeySystemAccess(m_keySystem);
 
-            // 5.3.3.2 Resolve promise with access and abort these steps.
-            resolve(access);
-            return;
+                // 5.3.3.2 Resolve promise with access and abort these steps.
+                resolve(access);
+                return;
+            }
         }
     }
 
     // 5.4 Reject promise with a new DOMException whose name is
     //     NotSupportedError.
     reject(blink::DOMException::create(blink::NotSupportedError, "There were no supported combinations in supportedConfigurations."));
 }
 
 } // namespace
 
@@ skipping 30 matching lines @@
         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.
     //    (no supportedConfigurations provided.)
 
     // Remainder of steps handled in common routine below.
-    return NavigatorRequestMediaKeySystemAccess::from(navigator).requestMediaKeySystemAccess(scriptState, keySystem, Vector<MediaKeySystemOptions>());
+    return NavigatorRequestMediaKeySystemAccess::from(navigator).requestMediaKeySystemAccess(scriptState, keySystem, Vector<MediaKeySystemConfiguration>());
 }
 
 ScriptPromise NavigatorRequestMediaKeySystemAccess::requestMediaKeySystemAccess(
     ScriptState* scriptState,
     Navigator& navigator,
     const String& keySystem,
-    const Vector<MediaKeySystemOptions>& supportedConfigurations)
+    const Vector<MediaKeySystemConfiguration>& supportedConfigurations)
 {
     // From https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#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."));
     }
 
     // Remainder of steps handled in common routine below.
     return NavigatorRequestMediaKeySystemAccess::from(navigator).requestMediaKeySystemAccess(
         scriptState, keySystem, supportedConfigurations);
 }
 
 ScriptPromise NavigatorRequestMediaKeySystemAccess::requestMediaKeySystemAccess(
     ScriptState* scriptState,
     const String& keySystem,
-    const Vector<MediaKeySystemOptions>& supportedConfigurations)
+    const Vector<MediaKeySystemConfiguration>& supportedConfigurations)
 {
     // Continued from above.
     // 3. If keySystem is not one of the Key Systems supported by the user
     //    agent, return a promise rejected with a new DOMException whose name
     //    is NotSupportedError. String comparison is case-sensitive.
     if (!isKeySystemSupportedWithContentType(keySystem, "")) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(NotSupportedError, "The key system specified is not supported."));
     }
 
     // 4. Let promise be a new promise.
     // 5. Asynchronously determine support, and if allowed, create and
     //    initialize the MediaKeySystemAccess object.
     // 6. Return promise.
     return MediaKeySystemAccessInitializer::create(scriptState, keySystem, supportedConfigurations);
 }
 
 const char* NavigatorRequestMediaKeySystemAccess::supplementName()
 {
     return "RequestMediaKeySystemAccess";
 }
 
 void NavigatorRequestMediaKeySystemAccess::trace(Visitor* visitor)
 {
     WillBeHeapSupplement<Navigator>::trace(visitor);
 }
 
 } // namespace blink