Delay posting Message event on MediaKeySession if no event handlers

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 "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
+        Release,
+        Message
     };
 
     Type type() const { return m_type; }
-    const Persistent<ContentDecryptionModuleResult> result() const { return m_result; }
-    // |data| is only valid for Update types.
-    const RefPtr<ArrayBuffer> data() const { return m_data; }
+
+    const Persistent<ContentDecryptionModuleResult> result() const
+    {
+        ASSERT(m_type == Update || m_type == Release);
+        return m_result;
+    }
+
+    const RefPtr<ArrayBuffer> data() const
+    {
+        ASSERT(m_type == Update);
+        return m_data;
+    }
+
+    RefPtrWillBeRawPtr<Event> event()
+    {
+        ASSERT(m_type == Message);
+        return m_event;
+    }
 
     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<ArrayBuffer>());
     }
 
+    static PendingAction* CreatePendingMessage(PassRefPtrWillBeRawPtr<Event> event)
+    {
+        ASSERT(event);
+        return new PendingAction(Message, event);
+    }
+
     ~PendingAction()
     {
     }
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_result);
     }
 
 private:
     PendingAction(Type type, ContentDecryptionModuleResult* result, PassRefPtr<ArrayBuffer> data)
         : m_type(type)
         , m_result(result)
         , m_data(data)
     {
     }
 
+    PendingAction(Type type, PassRefPtrWillBeRawPtr<Event> event)
+        : m_type(type)
+        , m_event(event)
+    {
+    }
+
     const Type m_type;
     const Member<ContentDecryptionModuleResult> m_result;
     const RefPtr<ArrayBuffer> m_data;
+    const RefPtrWillBeRawPtr<Event> m_event;
 };
 
 // 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<ArrayBuffer> initData, const String& sessionType);
     virtual ~MediaKeySessionInitializer();
 
@@ skipping 328 matching lines @@
             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;
+        case PendingAction::Message:
+            WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Message", this);
+            m_asyncEventQueue->enqueueEvent(action->event().release());
+            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 = ArrayBuffer::create(static_cast<const void*>(message), messageLength);
     init.destinationURL = destinationURL.string();
 
     RefPtrWillBeRawPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(EventTypeNames::message, init);
     event->setTarget(this);
+
+    if (!hasEventListeners()) {
+        // Since this event may be generated immediately after resolving the
+        // CreateSession() promise, it is possible that the JavaScript hasn't
+        // had time to run the .then() action and bind any necessary event
+        // handlers. If there are no event handlers connected, delay enqueuing
+        // this message to provide time for the JavaScript to run. This will
+        // also affect the (rare) case where there is no message handler
+        // attched during normal operation.
+        m_pendingActions.append(PendingAction::CreatePendingMessage(event.release()));
+        if (!m_actionTimer.isActive())
+            m_actionTimer.startOneShot(0, FROM_HERE);
+        return;
+    }
+
     m_asyncEventQueue->enqueueEvent(event.release());
 }
 
 void MediaKeySession::ready()
 {
     WTF_LOG(Media, "MediaKeySession(%p)::ready", this);
 
     RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::ready);
     event->setTarget(this);
     m_asyncEventQueue->enqueueEvent(event.release());
@@ skipping 101 matching lines @@
 {
     visitor->trace(m_error);
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_pendingActions);
     visitor->trace(m_keys);
     visitor->trace(m_closedPromise);
     EventTargetWithInlineData::trace(visitor);
 }
 
 }