Rename onneedkey event to onencrypted.

Source/modules/encryptedmedia/HTMLMediaElementEncryptedMedia.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/MediaKeyError.h"
 #include "core/html/MediaKeyEvent.h"
-#include "modules/encryptedmedia/MediaKeyNeededEvent.h"
+#include "modules/encryptedmedia/MediaEncryptedEvent.h"
 #include "modules/encryptedmedia/MediaKeys.h"
 #include "modules/encryptedmedia/SimpleContentDecryptionModuleResult.h"
 #include "platform/ContentDecryptionModuleResult.h"
 #include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "wtf/ArrayBuffer.h"
 #include "wtf/Functional.h"
 #include "wtf/Uint8Array.h"
 
 namespace blink {
 
 static void throwExceptionIfMediaKeyExceptionOccurred(const String& keySystem, const String& sessionId, WebMediaPlayer::MediaKeyException exception, ExceptionState& exceptionState)
 {
     switch (exception) {
     case WebMediaPlayer::MediaKeyExceptionNoError:
         return;
@@ skipping 246 matching lines @@
 
     // 1. If mediaKeys and the mediaKeys attribute are the same object, return
     //    a promise resolved with undefined.
     if (thisElement.m_mediaKeys == mediaKeys)
         return ScriptPromise::cast(scriptState, V8ValueTraits<V8UndefinedType>::toV8Value(V8UndefinedType(), scriptState->context()->Global(), scriptState->isolate()));
 
     // 2. Let promise be a new promise. Remaining steps done in handler.
     return SetMediaKeysHandler::create(scriptState, element, mediaKeys);
 }
 
-// Create a MediaKeyNeededEvent for WD EME.
-static PassRefPtrWillBeRawPtr<Event> createNeedKeyEvent(const String& contentType, const unsigned char* initData, unsigned initDataLength)
+// Create a MediaEncryptedEvent for WD EME.
+static PassRefPtrWillBeRawPtr<Event> createEncryptedEvent(const String& initDataType, const unsigned char* initData, unsigned initDataLength)
 {
-    MediaKeyNeededEventInit initializer;
-    initializer.contentType = contentType;
-    initializer.initData = Uint8Array::create(initData, initDataLength);
+    MediaEncryptedEventInit initializer;
+    initializer.initDataType = initDataType;
+    initializer.initData = ArrayBuffer::create(initData, initDataLength);
     initializer.bubbles = false;
     initializer.cancelable = false;
 
-    return MediaKeyNeededEvent::create(EventTypeNames::needkey, initializer);
+    return MediaEncryptedEvent::create(EventTypeNames::encrypted, initializer);
 }
 
 // Create a 'needkey' MediaKeyEvent for v0.1b EME.
-static PassRefPtrWillBeRawPtr<Event> createWebkitNeedKeyEvent(const String& contentType, const unsigned char* initData, unsigned initDataLength)
+static PassRefPtrWillBeRawPtr<Event> createWebkitNeedKeyEvent(const unsigned char* initData, unsigned initDataLength)
 {
     MediaKeyEventInit webkitInitializer;
     webkitInitializer.keySystem = String();
     webkitInitializer.sessionId = String();
     webkitInitializer.initData = Uint8Array::create(initData, initDataLength);
     webkitInitializer.bubbles = false;
     webkitInitializer.cancelable = false;
 
     return MediaKeyEvent::create(EventTypeNames::webkitneedkey, webkitInitializer);
 }
@@ skipping 180 matching lines @@
     initializer.message = Uint8Array::create(message, messageLength);
     initializer.defaultURL = KURL(defaultURL);
     initializer.bubbles = false;
     initializer.cancelable = false;
 
     RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeymessage, initializer);
     event->setTarget(&element);
     element.scheduleEvent(event.release());
 }
 
-void HTMLMediaElementEncryptedMedia::keyNeeded(HTMLMediaElement& element, const String& contentType, const unsigned char* initData, unsigned initDataLength)
+void HTMLMediaElementEncryptedMedia::keyNeeded(HTMLMediaElement& element, const String& initDataType, const unsigned char* initData, unsigned initDataLength)

[ddorwin, 2014/09/29 23:26:41]

We should rename this method. That involves the public API, which will involve
multiple steps. You might as well start the process now.

[sandersd (OOO until July 31), 2014/09/30 19:14:03]

Done.

 {
-    WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyNeeded: contentType=%s", contentType.utf8().data());
+    WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::keyNeeded: initDataType=%s", initDataType.utf8().data());
 
     if (RuntimeEnabledFeatures::encryptedMediaEnabled()) {
         // Send event for WD EME.
-        RefPtrWillBeRawPtr<Event> event = createNeedKeyEvent(contentType, initData, initDataLength);
+        // FIXME: Check origin before providing initData. http://crbug.com/418233.
+        RefPtrWillBeRawPtr<Event> event = createEncryptedEvent(initDataType, initData, initDataLength);
         event->setTarget(&element);
         element.scheduleEvent(event.release());
     }
 
     if (RuntimeEnabledFeatures::prefixedEncryptedMediaEnabled()) {
         // Send event for v0.1b EME.
-        RefPtrWillBeRawPtr<Event> event = createWebkitNeedKeyEvent(contentType, initData, initDataLength);
+        RefPtrWillBeRawPtr<Event> event = createWebkitNeedKeyEvent(initData, initDataLength);
         event->setTarget(&element);
         element.scheduleEvent(event.release());
     }
 }
 
 void HTMLMediaElementEncryptedMedia::playerDestroyed(HTMLMediaElement& element)
 {
 #if ENABLE(OILPAN)
     // FIXME: Oilpan: remove this once the media player is on the heap. crbug.com/378229
     if (element.isFinalizing())
@@ skipping 14 matching lines @@
     return thisElement.contentDecryptionModule();
 }
 
 void HTMLMediaElementEncryptedMedia::trace(Visitor* visitor)
 {
     visitor->trace(m_mediaKeys);
     WillBeHeapSupplement<HTMLMediaElement>::trace(visitor);
 }
 
 } // namespace blink