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 WebCore {
 
 // 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;
     Persistent<MediaKeySession> m_session;
     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 33 matching lines @@
     // creating the session on the Chromium side. As a result, we need to
     // create the session now.
     // FIXME: Add an API to allow the client interface to be specified later
     // to WebContentDecryptionModuleSession, and then creating the
     // MediaKeySession object can be done in completeWithSession().
     m_session = adoptRefCountedGarbageCollectedWillBeNoop(new MediaKeySession(executionContext(), m_mediaKeys));
     m_session->suspendIfNeeded();
 
     m_cdmSession = adoptPtr(cdm->createSession(m_session));
     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 41 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)
     : ActiveDOMObject(context)
     , m_keySystem(keys->keySystem())
     , m_asyncEventQueue(GenericEventQueue::create(this))
@@ skipping 20 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));

[ddorwin, 2014/07/16 22:34:57]

Does PassRefPtr make the release implicit or are you just assuming the reference
gets deleted when we exit this function? Would it be better to be explicit about
the transfer of ownership? (We may not even need a RefPtr if it's not required
by other parts of Blink.

[jrummell, 2014/07/18 21:56:00]

ArrayBuffer::create() returns a RefPtr, so I don't think we can get rid of it.
updateInternal() gets passed the RefPtr and simply passes it on. It should get
released if CreatePendingUpdate() doesn't grab the object (which is does when
assigning to |m_data|).

     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.
@@ skipping 22 matching lines @@
 }
 
 // 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);
 }
 
 }