Change initDataType and sessionType to be enums

Source/modules/encryptedmedia/MediaKeySession.cpp

 /*
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 37 matching lines @@
 #include "public/platform/WebContentDecryptionModuleSession.h"
 #include "public/platform/WebEncryptedMediaKeyInformation.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "wtf/ASCIICType.h"
 #include <cmath>
 #include <limits>
 
 namespace {
 
-// The list of possible values for |sessionType|.
-const char kTemporary[] = "temporary";
-const char kPersistentLicense[] = "persistent-license";
-const char kPersistentReleaseMessage[] = "persistent-release-message";
-
-// The list of possible values for |messageType|.
-const char kLicenseRequest[] = "license-request";
-const char kLicenseRenewal[] = "license-renewal";
-const char kLicenseRelease[] = "license-release";
-
 // Minimum and maximum length for session ids.
 enum {
     MinSessionIdLength = 1,
     MaxSessionIdLength = 512
 };
 
 } // namespace
 
 namespace blink {
 
 // Checks that |sessionId| looks correct and returns whether all checks pass.
 static bool isValidSessionId(const String& sessionId)
 {
     if ((sessionId.length() < MinSessionIdLength) || (sessionId.length() > MaxSessionIdLength))
         return false;
 
     if (!sessionId.containsOnlyASCII())
         return false;
 
     // Check that the sessionId only contains alphanumeric characters.
     for (unsigned i = 0; i < sessionId.length(); ++i) {
         if (!isASCIIAlphanumeric(sessionId[i]))
             return false;
     }
 
     return true;
 }
 
-// Checks that |initDataType| is a registered Initialization Data Type.
-static bool isRegisteredInitDataType(const String& initDataType)
-{
-    // List from https://w3c.github.io/encrypted-media/initdata-format-registry.html
-    return initDataType == "cenc" || initDataType == "keyids" || initDataType == "webm";
-}
-
 static String ConvertKeyStatusToString(const WebEncryptedMediaKeyInformation::KeyStatus status)
 {
     switch (status) {
     case WebEncryptedMediaKeyInformation::KeyStatus::Usable:
         return "usable";
     case WebEncryptedMediaKeyInformation::KeyStatus::Expired:
         return "expired";
     case WebEncryptedMediaKeyInformation::KeyStatus::OutputNotAllowed:
         return "output-not-allowed";
     case WebEncryptedMediaKeyInformation::KeyStatus::InternalError:
@@ skipping 33 matching lines @@
     {
         return m_result;
     }
 
     const PassRefPtr<DOMArrayBuffer> data() const
     {
         ASSERT(m_type == GenerateRequest || m_type == Update);
         return m_data;
     }
 
-    const String& initDataType() const
+    WebEncryptedMediaInitDataType initDataType() const
     {
         ASSERT(m_type == GenerateRequest);
-        return m_stringData;
+        return m_initDataType;
     }
 
     const String& sessionId() const
     {
         ASSERT(m_type == Load);
         return m_stringData;
     }
 
-    static PendingAction* CreatePendingGenerateRequest(ContentDecryptionModuleResult* result, const String& initDataType, PassRefPtr<DOMArrayBuffer> initData)
+    static PendingAction* CreatePendingGenerateRequest(ContentDecryptionModuleResult* result, WebEncryptedMediaInitDataType initDataType, PassRefPtr<DOMArrayBuffer> initData)
     {
         ASSERT(result);
         ASSERT(initData);
-        return new PendingAction(GenerateRequest, result, initDataType, initData);
+        return new PendingAction(GenerateRequest, result, initDataType, initData, String());
     }
 
     static PendingAction* CreatePendingLoadRequest(ContentDecryptionModuleResult* result, const String& sessionId)
     {
         ASSERT(result);
-        return new PendingAction(Load, result, sessionId, PassRefPtr<DOMArrayBuffer>());
+        return new PendingAction(Load, result, WebEncryptedMediaInitDataType::Unknown, PassRefPtr<DOMArrayBuffer>(), sessionId);
     }
 
     static PendingAction* CreatePendingUpdate(ContentDecryptionModuleResult* result, PassRefPtr<DOMArrayBuffer> data)
     {
         ASSERT(result);
         ASSERT(data);
-        return new PendingAction(Update, result, String(), data);
+        return new PendingAction(Update, result, WebEncryptedMediaInitDataType::Unknown, data, String());
     }
 
     static PendingAction* CreatePendingClose(ContentDecryptionModuleResult* result)
     {
         ASSERT(result);
-        return new PendingAction(Close, result, String(), PassRefPtr<DOMArrayBuffer>());
+        return new PendingAction(Close, result, WebEncryptedMediaInitDataType::Unknown, PassRefPtr<DOMArrayBuffer>(), String());
     }
 
     static PendingAction* CreatePendingRemove(ContentDecryptionModuleResult* result)
     {
         ASSERT(result);
-        return new PendingAction(Remove, result, String(), PassRefPtr<DOMArrayBuffer>());
+        return new PendingAction(Remove, result, WebEncryptedMediaInitDataType::Unknown, PassRefPtr<DOMArrayBuffer>(), String());
     }
 
     ~PendingAction()
     {
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_result);
     }
 
 private:
-    PendingAction(Type type, ContentDecryptionModuleResult* result, const String& stringData, PassRefPtr<DOMArrayBuffer> data)
+    PendingAction(Type type, ContentDecryptionModuleResult* result, WebEncryptedMediaInitDataType initDataType, PassRefPtr<DOMArrayBuffer> data, const String& stringData)
         : m_type(type)
         , m_result(result)
+        , m_initDataType(initDataType)
+        , m_data(data)
         , m_stringData(stringData)
-        , m_data(data)
     {
     }
 
     const Type m_type;
     const Member<ContentDecryptionModuleResult> m_result;
+    const WebEncryptedMediaInitDataType m_initDataType;
+    const RefPtr<DOMArrayBuffer> m_data;
     const String m_stringData;
-    const RefPtr<DOMArrayBuffer> m_data;
 };
 
 // This class wraps the promise resolver used when initializing a new session
 // and is passed to Chromium to fullfill the promise. This implementation of
 // completeWithSession() will resolve the promise with void, while
 // completeWithError() will reject the promise with an exception. complete()
 // is not expected to be called, and will reject the promise.
 class NewSessionResultPromise : public ContentDecryptionModuleResultPromise {
 public:
     NewSessionResultPromise(ScriptState* scriptState, MediaKeySession* session)
@@ skipping 71 matching lines @@
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_session);
         ContentDecryptionModuleResultPromise::trace(visitor);
     }
 
 private:
     Member<MediaKeySession> m_session;
 };
 
-MediaKeySession* MediaKeySession::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& sessionType)
+MediaKeySession* MediaKeySession::create(ScriptState* scriptState, MediaKeys* mediaKeys, WebEncryptedMediaSessionType sessionType)
 {
-    ASSERT(isValidSessionType(sessionType));
     RefPtrWillBeRawPtr<MediaKeySession> session = new MediaKeySession(scriptState, mediaKeys, sessionType);
     session->suspendIfNeeded();
     return session.get();
 }
 
-bool MediaKeySession::isValidSessionType(const String& sessionType)
+WebEncryptedMediaInitDataType MediaKeySession::convertInitDataType(const String& initDataType)
 {
-    return (sessionType == kTemporary || sessionType == kPersistentLicense || sessionType == kPersistentReleaseMessage);
+    if (initDataType == "cenc")
+        return WebEncryptedMediaInitDataType::Cenc;
+    if (initDataType == "keyids")
+        return WebEncryptedMediaInitDataType::Keyids;
+    if (initDataType == "webm")
+        return WebEncryptedMediaInitDataType::Webm;
+
+    // |initDataType| is not restricted in the idl, so anything is possible.
+    return WebEncryptedMediaInitDataType::Unknown;
 }
 
-MediaKeySession::MediaKeySession(ScriptState* scriptState, MediaKeys* mediaKeys, const String& sessionType)
+WebEncryptedMediaSessionType MediaKeySession::convertSessionType(const String& sessionType)
+{
+    if (sessionType == "temporary")
+        return WebEncryptedMediaSessionType::Temporary;
+    if (sessionType == "persistent-license")
+        return WebEncryptedMediaSessionType::PersistentLicense;
+    if (sessionType == "persistent-release-message")
+        return WebEncryptedMediaSessionType::PersistentReleaseMessage;
+
+    ASSERT_NOT_REACHED();
+    return WebEncryptedMediaSessionType::Unknown;
+}
+
+MediaKeySession::MediaKeySession(ScriptState* scriptState, MediaKeys* mediaKeys, WebEncryptedMediaSessionType sessionType)
     : ActiveDOMObject(scriptState->executionContext())
     , m_keySystem(mediaKeys->keySystem())
     , m_asyncEventQueue(GenericEventQueue::create(this))
     , m_mediaKeys(mediaKeys)
     , m_sessionType(sessionType)
     , m_expiration(std::numeric_limits<double>::quiet_NaN())
     , m_keyStatusesMap(new MediaKeyStatusMap())
     , m_isUninitialized(true)
     , m_isCallable(false)
     , m_isClosed(false)
@@ skipping 17 matching lines @@
     // 3.2 Let the expiration attribute be NaN.
     ASSERT(std::isnan(m_expiration));
 
     // 3.3 Let the closed attribute be a new promise.
     ASSERT(!closed(scriptState).isUndefinedOrNull());
 
     // 3.4 Let the keyStatuses attribute be empty.
     ASSERT(m_keyStatusesMap->size() == 0);
 
     // 3.5 Let the session type be sessionType.
-    ASSERT(isValidSessionType(m_sessionType));
+    ASSERT(m_sessionType != WebEncryptedMediaSessionType::Unknown);
 
     // 3.6 Let uninitialized be true.
     ASSERT(m_isUninitialized);
 
     // 3.7 Let callable be false.
     ASSERT(!m_isCallable);
 
     // 3.8 Let the use distinctive identifier value be this object's
     // use distinctive identifier.
     // FIXME: Implement this (http://crbug.com/448922).
@@ skipping 22 matching lines @@
 ScriptPromise MediaKeySession::closed(ScriptState* scriptState)
 {
     return m_closedPromise->promise(scriptState->world());
 }
 
 MediaKeyStatusMap* MediaKeySession::keyStatuses()
 {
     return m_keyStatusesMap;
 }
 
-ScriptPromise MediaKeySession::generateRequest(ScriptState* scriptState, const String& initDataType, const DOMArrayPiece& initData)
+ScriptPromise MediaKeySession::generateRequest(ScriptState* scriptState, const String& initDataTypeString, const DOMArrayPiece& initData)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::generateRequest %s", this, initDataType.ascii().data());
+    WTF_LOG(Media, "MediaKeySession(%p)::generateRequest %s", this, initDataTypeString.ascii().data());
 
     // From https://w3c.github.io/encrypted-media/#generateRequest:
     // Generates a request based on the initData. When this method is invoked,
     // the user agent must run the following steps:
 
     // 1. If this object's uninitialized value is false, return a promise
     //    rejected with a new DOMException whose name is "InvalidStateError".
     if (!m_isUninitialized)
         return CreateRejectedPromiseAlreadyInitialized(scriptState);
 
     // 2. Let this object's uninitialized be false.
     m_isUninitialized = false;
 
     // 3. If initDataType is an empty string, return a promise rejected with a
     //    new DOMException whose name is "InvalidAccessError".
-    if (initDataType.isEmpty()) {
+    if (initDataTypeString.isEmpty()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The initDataType parameter is empty."));
     }
 
     // 4. If initData is an empty array, return a promise rejected with a new
     //    DOMException whose name is"InvalidAccessError".
     if (!initData.byteLength()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The initData parameter is empty."));
     }
 
     // 5. If the Key System implementation represented by this object's cdm
     //    implementation value does not support initDataType as an
     //    Initialization Data Type, return a promise rejected with a new
     //    DOMException whose name is NotSupportedError. String comparison
     //    is case-sensitive.
     //    (blink side doesn't know what the CDM supports, so the proper check
     //     will be done on the Chromium side. However, we can verify that
     //     |initDataType| is one of the registered values.)
-    if (!isRegisteredInitDataType(initDataType)) {
+    WebEncryptedMediaInitDataType initDataType = convertInitDataType(initDataTypeString);
+    if (initDataType == WebEncryptedMediaInitDataType::Unknown) {
         return ScriptPromise::rejectWithDOMException(
-            scriptState, DOMException::create(NotSupportedError, "The initialization data type '" + initDataType + "' is not a registered Initialization Data Type."));
+            scriptState, DOMException::create(NotSupportedError, "The initialization data type '" + initDataTypeString + "' is not supported."));
     }
 
     // 6. Let init data be a copy of the contents of the initData parameter.
     RefPtr<DOMArrayBuffer> initDataBuffer = DOMArrayBuffer::create(initData.data(), initData.byteLength());
 
     // 7. Let session type be this object's session type.
     //    (Done in constructor.)
 
     // 8. Let promise be a new promise.
     NewSessionResultPromise* result = new NewSessionResultPromise(scriptState, this);
@@ skipping 28 matching lines @@
     // 3. If sessionId is an empty string, return a promise rejected with a
     //    new DOMException whose name is "InvalidAccessError".
     if (sessionId.isEmpty()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The sessionId parameter is empty."));
     }
 
     // 4. If this object's session type is not "persistent-license" or
     //    "persistent-release-message", return a promise rejected with a
     //    new DOMException whose name is InvalidAccessError.
-    if (m_sessionType != kPersistentLicense && m_sessionType != kPersistentReleaseMessage) {
+    if (m_sessionType != WebEncryptedMediaSessionType::PersistentLicense && m_sessionType != WebEncryptedMediaSessionType::PersistentReleaseMessage) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The session type is not persistent."));
     }
 
     // 5. If the Key System implementation represented by this object's cdm
     //    implementation value does not support loading previous sessions,
     //    return a promise rejected with a new DOMException whose name is
     //    NotSupportedError.
     // FIXME: Implement this (http://crbug.com/448922).
 
@@ skipping 94 matching lines @@
     // method is invoked, the user agent must run the following steps:
 
     // 1. If this object's callable value is false, return a promise rejected
     //    with a new DOMException whose name is "InvalidStateError".
     if (!m_isCallable)
         return CreateRejectedPromiseNotCallable(scriptState);
 
     // 2. If this object's session type is not "persistent-license" or
     //    "persistent-release-message", return a promise rejected with a
     //    new DOMException whose name is InvalidAccessError.
-    if (m_sessionType != kPersistentLicense && m_sessionType != kPersistentReleaseMessage) {
+    if (m_sessionType != WebEncryptedMediaSessionType::PersistentLicense && m_sessionType != WebEncryptedMediaSessionType::PersistentReleaseMessage) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The session type is not persistent."));
     }
 
     // 3. If the Session Close algorithm has been run on this object, return a
     //    promise rejected with a new DOMException whose name is
     //    "InvalidStateError".
     if (m_isClosed) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidStateError, "The session is already closed."));
@@ skipping 176 matching lines @@
     // The following steps are run:
     // 1. Let the session be the specified MediaKeySession object.
     // 2. Queue a task to fire a simple event named message at the session.
     //    The event is of type MediaKeyMessageEvent and has:
     //    -> messageType = the specified message type
     //    -> message = the specified message
 
     MediaKeyMessageEventInit init;
     switch (messageType) {
     case WebContentDecryptionModuleSession::Client::MessageType::LicenseRequest:
-        init.setMessageType(kLicenseRequest);
+        init.setMessageType("license-request");
         break;
     case WebContentDecryptionModuleSession::Client::MessageType::LicenseRenewal:
-        init.setMessageType(kLicenseRenewal);
+        init.setMessageType("license-renewal");
         break;
     case WebContentDecryptionModuleSession::Client::MessageType::LicenseRelease:
-        init.setMessageType(kLicenseRelease);
+        init.setMessageType("license-release");
         break;
     }
     init.setMessage(DOMArrayBuffer::create(static_cast<const void*>(message), messageLength));
 
     RefPtrWillBeRawPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(EventTypeNames::message, init);
     event->setTarget(this);
     m_asyncEventQueue->enqueueEvent(event.release());
 }
 
 void MediaKeySession::close()
@@ skipping 114 matching lines @@
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_pendingActions);
     visitor->trace(m_mediaKeys);
     visitor->trace(m_keyStatusesMap);
     visitor->trace(m_closedPromise);
     RefCountedGarbageCollectedEventTargetWithInlineData<MediaKeySession>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink