Implement MediaKeys.setServerCertificate()

Source/modules/encryptedmedia/MediaKeys.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 17 matching lines @@
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/encryptedmedia/MediaKeyMessageEvent.h"
 #include "modules/encryptedmedia/MediaKeySession.h"
 #include "modules/encryptedmedia/MediaKeysController.h"
+#include "modules/encryptedmedia/SimpleContentDecryptionModuleResult.h"
 #include "platform/ContentType.h"
 #include "platform/Logging.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/Timer.h"
 #include "platform/UUID.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "wtf/ArrayBuffer.h"
 #include "wtf/ArrayBufferView.h"
 #include "wtf/RefPtr.h"
@@ skipping 17 matching lines @@
     ContentType type(contentType);
     String codecs = type.parameter("codecs");
     return MIMETypeRegistry::isSupportedEncryptedMediaMIMEType(keySystem, type.type(), codecs);
 }
 
 static ScriptPromise createRejectedPromise(ScriptState* scriptState, ExceptionCode error, const String& errorMessage)
 {
     return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(error, errorMessage));
 }
 
+// A class holding a pending action.
+class MediaKeys::PendingAction : public GarbageCollectedFinalized<MediaKeys::PendingAction> {
+public:
+    const Persistent<ContentDecryptionModuleResult> result() const
+    {
+        return m_result;
+    }
+
+    const RefPtr<ArrayBuffer> data() const
+    {
+        return m_data;
+    }
+
+    static PendingAction* CreatePendingSetServerCertificate(ContentDecryptionModuleResult* result, PassRefPtr<ArrayBuffer> serverCertificate)
+    {
+        ASSERT(result);
+        ASSERT(serverCertificate);
+        return new PendingAction(result, serverCertificate);
+    }
+
+    ~PendingAction()
+    {
+    }
+
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_result);
+    }
+
+private:
+    PendingAction(ContentDecryptionModuleResult* result, PassRefPtr<ArrayBuffer> data)
+        : m_result(result)
+        , m_data(data)
+    {
+    }
+
+    const Member<ContentDecryptionModuleResult> m_result;
+    const RefPtr<ArrayBuffer> m_data;
+};
+
 // This class allows a MediaKeys object to be created asynchronously.
 class MediaKeysInitializer : public ScriptPromiseResolver {
     WTF_MAKE_NONCOPYABLE(MediaKeysInitializer);
 
 public:
     static ScriptPromise create(ScriptState*, const String& keySystem);
     virtual ~MediaKeysInitializer();
 
 private:
     MediaKeysInitializer(ScriptState*, const String& keySystem);
@@ skipping 85 matching lines @@
     // 3. Let promise be a new promise.
     // 4. Asynchronously create and initialize the MediaKeys.
     // 5. Return promise.
     return MediaKeysInitializer::create(scriptState, keySystem);
 }
 
 MediaKeys::MediaKeys(ExecutionContext* context, const String& keySystem, PassOwnPtr<WebContentDecryptionModule> cdm)
     : ContextLifecycleObserver(context)
     , m_keySystem(keySystem)
     , m_cdm(cdm)
+    , m_timer(this, &MediaKeys::timerFired)
 {
     WTF_LOG(Media, "MediaKeys(%p)::MediaKeys", this);
 
     // Step 4.4 of MediaKeys::create():
     // 4.4.1 Set the keySystem attribute to keySystem.
     ASSERT(!m_keySystem.isEmpty());
 }
 
 MediaKeys::~MediaKeys()
 {
@@ skipping 13 matching lines @@
     // FIXME: Check whether sessionType is actually supported by the CDM.
     ASSERT(sessionType == kTemporary || sessionType == kPersistent);
 
     // 2. Let session be a new MediaKeySession object, and initialize it as
     //    follows:
     //    (Initialization is performed in the constructor.)
     // 3. Return session.
     return MediaKeySession::create(scriptState, this, sessionType);
 }
 
+ScriptPromise MediaKeys::setServerCertificate(ScriptState* scriptState, ArrayBuffer* serverCertificate)
+{
+    RefPtr<ArrayBuffer> serverCertificateCopy = ArrayBuffer::create(serverCertificate->data(), serverCertificate->byteLength());
+    return setServerCertificateInternal(scriptState, serverCertificateCopy.release());
+}
+
+ScriptPromise MediaKeys::setServerCertificate(ScriptState* scriptState, ArrayBufferView* serverCertificate)
+{
+    RefPtr<ArrayBuffer> serverCertificateCopy = ArrayBuffer::create(serverCertificate->baseAddress(), serverCertificate->byteLength());
+    return setServerCertificateInternal(scriptState, serverCertificateCopy.release());
+}
+
+ScriptPromise MediaKeys::setServerCertificateInternal(ScriptState* scriptState, PassRefPtr<ArrayBuffer> serverCertificate)
+{
+    // From https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#dom-setservercertificate:
+    // The setServerCertificate(serverCertificate) method provides a server
+    // certificate to be used to encrypt messages to the license server.
+    // It must run the following steps:
+    // 1. If serverCertificate is an empty array, return a promise rejected
+    //    with a new DOMException whose name is "InvalidAccessError".
+    if (!serverCertificate->byteLength()) {
+        return ScriptPromise::rejectWithDOMException(
+            scriptState, DOMException::create(InvalidAccessError, "The serverCertificate parameter is empty."));
+    }
+
+    // 2. If the keySystem does not support server certificates, return a
+    //    promise rejected with a new DOMException whose name is
+    //    "NotSupportedError".
+    //    (Let the CDM decide whether to support this or not.)
+
+    // 3. Let certificate be a copy of the contents of the serverCertificate
+    //    parameter.
+    //    (Done in caller.)
+
+    // 4. Let promise be a new promise.
+    SimpleContentDecryptionModuleResult* result = new SimpleContentDecryptionModuleResult(scriptState);
+    ScriptPromise promise = result->promise();
+
+    // 5. Run the following steps asynchronously (documented in timerFired()).
+    m_pendingActions.append(PendingAction::CreatePendingSetServerCertificate(result, serverCertificate));

[sandersd (OOO until July 31), 2014/09/11 23:37:13]

If the Chromium promises implementation is correct, this shouldn't be different
from just calling cdm->setCertificate(), which would be simpler.

[jrummell, 2014/09/12 20:49:03]

The problem is that ClearKey will resolve the promise synchronously, so we
technically violate the spec. Any calls that go through Pepper will be async
though. ddorwin@, WDYT? Should we make the Chromium side do the async work?

[ddorwin, 2014/09/15 23:10:56]

As discussed, let's keep it simple, consistent with the spec text, and
consistent with other methods.

[jrummell, 2014/09/17 23:39:24]

Acknowledged.

+    if (!m_timer.isActive())
+        m_timer.startOneShot(0, FROM_HERE);
+
+    // 6. Return promise.
+    return promise;
+}
+
 bool MediaKeys::isTypeSupported(const String& keySystem, const String& contentType)
 {
     WTF_LOG(Media, "MediaKeys::isTypeSupported(%s, %s)", keySystem.ascii().data(), contentType.ascii().data());
 
     // 1. If keySystem is an empty string, return false and abort these steps.
     if (keySystem.isEmpty())
         return false;
 
     // 2. If keySystem contains an unrecognized or unsupported Key System, return false and abort
     // these steps. Key system string comparison is case-sensitive.
     if (!isKeySystemSupportedWithContentType(keySystem, ""))
         return false;
 
     // 3. If contentType is an empty string, return true and abort these steps.
     if (contentType.isEmpty())
         return true;
 
     // 4. If the Key System specified by keySystem does not support decrypting the container and/or
     // codec specified by contentType, return false and abort these steps.
     return isKeySystemSupportedWithContentType(keySystem, contentType);
 }
 
+void MediaKeys::timerFired(Timer<MediaKeys>*)
+{
+    ASSERT(m_pendingActions.size());
+
+    // Resolving promises now run synchronously and may result in additional

[ddorwin, 2014/09/15 23:10:56]

"now"? I assume this was inspired by the change in behavior. We should probably
remove such text since it is already stale.

[jrummell, 2014/09/17 23:39:24]

Comment removed.

+    // actions getting added to the queue. As a result, swap the queue to

[ddorwin, 2014/09/15 23:10:56]

nit: s/As a result,/Therefore,/

[jrummell, 2014/09/17 23:39:24]

Changed.

+    // a local copy to avoid problems if this happens.
+    HeapDeque<Member<PendingAction> > pendingActions;
+    pendingActions.swap(m_pendingActions);
+
+    while (!pendingActions.isEmpty()) {
+        PendingAction* action = pendingActions.takeFirst();
+        WTF_LOG(Media, "MediaKeys(%p)::timerFired: Certificate", this);
+
+        // 5.1 Let cdm be the cdm during the initialization of this object.
+        WebContentDecryptionModule* cdm = contentDecryptionModule();
+
+        // 5.2 Use the cdm to process certificate.
+        cdm->setServerCertificate(static_cast<unsigned char*>(action->data()->data()), action->data()->byteLength(), action->result()->result());
+        // 5.3 If any of the preceding steps failed, reject promise with a
+        //     new DOMException whose name is the appropriate error name.
+        // 5.4 Resolve promise.
+        // These are handled by Chromium and the CDM.

[ddorwin, 2014/09/15 23:10:56]

Add () as elsewhere?

[jrummell, 2014/09/17 23:39:24]

Done.

+    }
+}
+
 WebContentDecryptionModule* MediaKeys::contentDecryptionModule()
 {
     return m_cdm.get();
 }
 
 void MediaKeys::trace(Visitor* visitor)
 {
+    visitor->trace(m_pendingActions);
 }
 
 void MediaKeys::contextDestroyed()
 {
     ContextLifecycleObserver::contextDestroyed();
 
     // We don't need the CDM anymore.
     m_cdm.clear();
 }
 
 } // namespace blink