Change EME WebIDL to use ArrayBuffer/ArrayBufferView.

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 27 matching lines @@
 #include "modules/encryptedmedia/MediaKeys.h"
 #include "modules/encryptedmedia/SimpleContentDecryptionModuleResult.h"
 #include "platform/ContentDecryptionModuleResult.h"
 #include "platform/Logging.h"
 #include "platform/Timer.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebContentDecryptionModuleException.h"
 #include "public/platform/WebContentDecryptionModuleSession.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
-#include "wtf/Uint8Array.h"
+#include "wtf/ArrayBuffer.h"
+#include "wtf/ArrayBufferView.h"
 
 namespace blink {
 
 // A class holding a pending action.
 class MediaKeySession::PendingAction : public GarbageCollectedFinalized<MediaKeySession::PendingAction> {
 public:
     enum Type {
         Update,
         Release
     };
 
     Type type() const { return m_type; }
     const Persistent<ContentDecryptionModuleResult> result() const { return m_result; }
     // |data| is only valid for Update types.
-    const RefPtr<Uint8Array> data() const { return m_data; }
+    const RefPtr<ArrayBuffer> data() const { return m_data; }
 
-    static PendingAction* CreatePendingUpdate(ContentDecryptionModuleResult* result, PassRefPtr<Uint8Array> data)
+    static PendingAction* CreatePendingUpdate(ContentDecryptionModuleResult* result, PassRefPtr<ArrayBuffer> data)
     {
         ASSERT(result);
         ASSERT(data);
         return new PendingAction(Update, result, data);
     }
 
     static PendingAction* CreatePendingRelease(ContentDecryptionModuleResult* result)
     {
         ASSERT(result);
-        return new PendingAction(Release, result, PassRefPtr<Uint8Array>());
+        return new PendingAction(Release, result, PassRefPtr<ArrayBuffer>());
     }
 
     ~PendingAction()
     {
     }
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_result);
     }
 
 private:
-    PendingAction(Type type, ContentDecryptionModuleResult* result, PassRefPtr<Uint8Array> data)
+    PendingAction(Type type, ContentDecryptionModuleResult* result, PassRefPtr<ArrayBuffer> data)
         : m_type(type)
         , m_result(result)
         , m_data(data)
     {
     }
 
     const Type m_type;
     const Member<ContentDecryptionModuleResult> m_result;
-    const RefPtr<Uint8Array> m_data;
+    const RefPtr<ArrayBuffer> m_data;
 };
 
 // This class allows a MediaKeySession object to be created asynchronously.
 class MediaKeySessionInitializer : public ScriptPromiseResolver {
     WTF_MAKE_NONCOPYABLE(MediaKeySessionInitializer);
 
 public:
-    static ScriptPromise create(ScriptState*, MediaKeys*, const String& initDataType, PassRefPtr<Uint8Array> initData, const String& sessionType);
+    static ScriptPromise create(ScriptState*, MediaKeys*, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType);
     virtual ~MediaKeySessionInitializer();
 
     void completeWithSession(blink::WebContentDecryptionModuleResult::SessionStatus);
     void completeWithDOMException(ExceptionCode, const String& errorMessage);
 
 private:
-    MediaKeySessionInitializer(ScriptState*, MediaKeys*, const String& initDataType, PassRefPtr<Uint8Array> initData, const String& sessionType);
+    MediaKeySessionInitializer(ScriptState*, MediaKeys*, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType);
     void timerFired(Timer<MediaKeySessionInitializer>*);
 
     Persistent<MediaKeys> m_mediaKeys;
     OwnPtr<blink::WebContentDecryptionModuleSession> m_cdmSession;
 
     // The next 3 values are simply the initialization data saved so that the
     // asynchronous creation has the data needed.
     String m_initDataType;
-    RefPtr<Uint8Array> m_initData;
+    RefPtr<ArrayBuffer> m_initData;
     String m_sessionType;
 
     Timer<MediaKeySessionInitializer> m_timer;
 };
 
 // Represents the result used when a new WebContentDecryptionModuleSession
 // object has been created. Needed as MediaKeySessionInitializer can't be both
 // a ScriptPromiseResolver and ContentDecryptionModuleResult at the same time.
 class NewMediaKeySessionResult FINAL : public ContentDecryptionModuleResult {
 public:
@@ skipping 16 matching lines @@
 
     virtual void completeWithError(blink::WebContentDecryptionModuleException code, unsigned long systemCode, const blink::WebString& message) OVERRIDE
     {
         m_initializer->completeWithDOMException(WebCdmExceptionToExceptionCode(code), message);
     }
 
 private:
     MediaKeySessionInitializer* m_initializer;
 };
 
-ScriptPromise MediaKeySessionInitializer::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<Uint8Array> initData, const String& sessionType)
+ScriptPromise MediaKeySessionInitializer::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType)
 {
     RefPtr<MediaKeySessionInitializer> initializer = adoptRef(new MediaKeySessionInitializer(scriptState, mediaKeys, initDataType, initData, sessionType));
     initializer->suspendIfNeeded();
     initializer->keepAliveWhilePending();
     return initializer->promise();
 }
 
-MediaKeySessionInitializer::MediaKeySessionInitializer(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<Uint8Array> initData, const String& sessionType)
+MediaKeySessionInitializer::MediaKeySessionInitializer(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType)
     : ScriptPromiseResolver(scriptState)
     , m_mediaKeys(mediaKeys)
     , m_initDataType(initDataType)
     , m_initData(initData)
     , m_sessionType(sessionType)
     , m_timer(this, &MediaKeySessionInitializer::timerFired)
 {
     WTF_LOG(Media, "MediaKeySessionInitializer::MediaKeySessionInitializer");
 
     // Start the timer so that MediaKeySession can be created asynchronously.
@@ skipping 23 matching lines @@
     //       a new DOMException whose name is "NotSupportedError".
     // 7.4.3 Let request be a request (e.g. a license request) generated based
     //       on the init data, which is interpreteted per initDataType, and
     //       sessionType. If sessionType is "temporary", the request is for a
     //       temporary non-persisted license. If sessionType is "persistent",
     //       the request is for a persistable license.
     // 7.4.4 If the init data indicates a default URL, let default URL be
     //       that URL. The URL may be validated and/or normalized.
     m_cdmSession = adoptPtr(cdm->createSession());
     NewMediaKeySessionResult* result = new NewMediaKeySessionResult(this);
-    m_cdmSession->initializeNewSession(m_initDataType, m_initData->data(), m_initData->length(), m_sessionType, result->result());
+    m_cdmSession->initializeNewSession(m_initDataType, static_cast<unsigned char*>(m_initData->data()), m_initData->byteLength(), m_sessionType, result->result());
 
     WTF_LOG(Media, "MediaKeySessionInitializer::timerFired done");
     // Note: As soon as the promise is resolved (or rejected), the
     // ScriptPromiseResolver object (|this|) is freed. So if
     // initializeNewSession() is synchronous, access to any members will crash.
 }
 
 void MediaKeySessionInitializer::completeWithSession(blink::WebContentDecryptionModuleResult::SessionStatus status)
 {
     WTF_LOG(Media, "MediaKeySessionInitializer::completeWithSession");
@@ skipping 43 matching lines @@
     }
     ASSERT_NOT_REACHED();
 }
 
 void MediaKeySessionInitializer::completeWithDOMException(ExceptionCode code, const String& errorMessage)
 {
     WTF_LOG(Media, "MediaKeySessionInitializer::completeWithDOMException");
     reject(DOMException::create(code, errorMessage));
 }
 
-ScriptPromise MediaKeySession::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<Uint8Array> initData, const String& sessionType)
+ScriptPromise MediaKeySession::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType)
 {
     // Since creation is done asynchronously, use MediaKeySessionInitializer
     // to do it.
     return MediaKeySessionInitializer::create(scriptState, mediaKeys, initDataType, initData, sessionType);
 }
 
 MediaKeySession::MediaKeySession(ExecutionContext* context, MediaKeys* keys, PassOwnPtr<blink::WebContentDecryptionModuleSession> cdmSession)
     : ActiveDOMObject(context)
     , m_keySystem(keys->keySystem())
     , m_asyncEventQueue(GenericEventQueue::create(this))
@@ skipping 34 matching lines @@
 void MediaKeySession::setError(MediaKeyError* error)
 {
     m_error = error;
 }
 
 String MediaKeySession::sessionId() const
 {
     return m_session->sessionId();
 }
 
-ScriptPromise MediaKeySession::update(ScriptState* scriptState, Uint8Array* response)
+ScriptPromise MediaKeySession::update(ScriptState* scriptState, ArrayBuffer* response)
+{
+    RefPtr<ArrayBuffer> responseCopy = ArrayBuffer::create(response->data(), response->byteLength());
+    return updateInternal(scriptState, responseCopy.release());
+}
+
+ScriptPromise MediaKeySession::update(ScriptState* scriptState, ArrayBufferView* response)
+{
+    RefPtr<ArrayBuffer> responseCopy = ArrayBuffer::create(response->baseAddress(), response->byteLength());
+    return updateInternal(scriptState, responseCopy.release());
+}
+
+ScriptPromise MediaKeySession::updateInternal(ScriptState* scriptState, PassRefPtr<ArrayBuffer> response)
 {
     WTF_LOG(Media, "MediaKeySession(%p)::update", this);
     ASSERT(!m_isClosed);
 
     // From <https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#dom-update>:
     // The update(response) method provides messages, including licenses, to the
     // CDM. It must run the following steps:
     //
     // 1. If response is an empty array, return a promise rejected with a new
     //    DOMException whose name is "InvalidAccessError" and that has the
     //    message "The response parameter is empty."
-    if (!response->length()) {
+    if (!response->byteLength()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The response parameter is empty."));
     }
 
     // 2. Let message be a copy of the contents of the response parameter.
-    RefPtr<Uint8Array> responseCopy = Uint8Array::create(response->data(), response->length());
+    //    (Copied in the caller.)
 
     // 3. Let promise be a new promise.
     SimpleContentDecryptionModuleResult* result = new SimpleContentDecryptionModuleResult(scriptState);
     ScriptPromise promise = result->promise();
 
     // 4. Run the following steps asynchronously (documented in
     //    actionTimerFired())
-    m_pendingActions.append(PendingAction::CreatePendingUpdate(result, responseCopy.release()));
+    m_pendingActions.append(PendingAction::CreatePendingUpdate(result, response));
     if (!m_actionTimer.isActive())
         m_actionTimer.startOneShot(0, FROM_HERE);
 
     // 5. Return promise.
     return promise;
 }
 
 ScriptPromise MediaKeySession::release(ScriptState* scriptState)
 {
     WTF_LOG(Media, "MediaKeySession(%p)::release", this);
@@ skipping 39 matching lines @@
 
     while (!pendingActions.isEmpty()) {
         PendingAction* action = pendingActions.takeFirst();
 
         switch (action->type()) {
         case PendingAction::Update:
             WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Update", this);
             // NOTE: Continued from step 4 of MediaKeySession::update().
             // Continue the update call by passing message to the cdm. Once
             // completed, it will resolve/reject the promise.
-            m_session->update(action->data()->data(), action->data()->length(), action->result()->result());
+            m_session->update(static_cast<unsigned char*>(action->data()->data()), action->data()->byteLength(), action->result()->result());
             break;
         case PendingAction::Release:
             WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Release", this);
             // NOTE: Continued from step 3 of MediaKeySession::release().
             // 3.1 Let cdm be the cdm loaded in create().
             // 3.2 Use the cdm to execute the following steps:
             // 3.2.1 Process the close request. Do not remove stored session data.
             // 3.2.2 If the previous step caused the session to be closed, run the
             //       Session Close algorithm on this object.
             // 3.3 Resolve promise with undefined.
             m_session->release(action->result()->result());
             break;
         }
     }
 }
 
 // Queue a task to fire a simple event named keymessage at the new object
 void MediaKeySession::message(const unsigned char* message, size_t messageLength, const blink::WebURL& destinationURL)
 {
     WTF_LOG(Media, "MediaKeySession(%p)::message", this);
 
     MediaKeyMessageEventInit init;
     init.bubbles = false;
     init.cancelable = false;
-    init.message = Uint8Array::create(message, messageLength);
+    init.message = ArrayBuffer::create(static_cast<const void*>(message), messageLength);
     init.destinationURL = destinationURL.string();
 
     RefPtrWillBeRawPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(EventTypeNames::message, init);
     event->setTarget(this);
     m_asyncEventQueue->enqueueEvent(event.release());
 }
 
 void MediaKeySession::ready()
 {
     WTF_LOG(Media, "MediaKeySession(%p)::ready", this);
@@ skipping 103 matching lines @@
 void MediaKeySession::trace(Visitor* visitor)
 {
     visitor->trace(m_error);
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_pendingActions);
     visitor->trace(m_keys);
     EventTargetWithInlineData::trace(visitor);
 }
 
 }