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());

[ddorwin, 2014/08/12 22:31:45]

Won't ".release()" this fail to compile with Oilpan enabled (event will be a
RawPtr)?

[jrummell, 2014/08/12 23:12:43]

With Oilpan there is a RawPtr class that has all the methods that RefPtr has, so
it's not an issue. When it actually gets converted to T* all the methods will
have to go away.

+            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.

[ddorwin, 2014/08/12 22:31:45]

Is this guaranteed to be allow sufficient time for the JS to run?

This will also affect the (rare) case where there is no message handler during
normal operation. It's unfortunate that the behavior is different, but delaying
all messages seems unnecessary. You might at least note this here.

[jrummell, 2014/08/12 23:12:43]

For testing I added DCHECK(hasEventListeners()) in actionTimerFired() and it
succeeded. However, that doesn't guarantee that this will be enough time with
slower/faster/more/less processors, but it does give time for this to happen.
Added comment. However, if they have no handler, it's just that the event will
get dropped a little later.

+        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);
 }
 
 }