Make unprefixed EME APIs use platform and Chromium.

Source/modules/encryptedmedia/MediaKeySession.h

 /*
  * 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 15 matching lines @@
 #ifndef MediaKeySession_h
 #define MediaKeySession_h
 
 #if ENABLE(ENCRYPTED_MEDIA_V2)
 
 #include "bindings/v8/ScriptWrappable.h"
 #include "core/dom/ContextDestructionObserver.h"
 #include "core/dom/EventTarget.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/platform/Timer.h"
+#include "core/platform/graphics/CDMSession.h"
 #include "wtf/Deque.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/Uint8Array.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 class GenericEventQueue;
 class MediaKeyError;
 class MediaKeys;
+class CDM;
 class CDMSession;
 
-class MediaKeySession : public RefCounted<MediaKeySession>, public ScriptWrappable, public EventTarget, public ContextDestructionObserver {
+// References are held by JS and MediaKeys.
+// Because this object controls the lifetime of the CDMSession, it may outlive
+// any references to it as long as the MediaKeys object is alive.
+// The CDMSession has the same lifetime as this object.
+class MediaKeySession
+    : public RefCounted<MediaKeySession>, public ScriptWrappable, public EventTarget, public ContextDestructionObserver
+    , private CDMSessionClient {
 public:
-    static PassRefPtr<MediaKeySession> create(ScriptExecutionContext*, MediaKeys*, const String& keySystem);
+    static PassRefPtr<MediaKeySession> create(ScriptExecutionContext*, CDM&, MediaKeys*);
     ~MediaKeySession();
 
     const String& keySystem() const { return m_keySystem; }
-    const String& sessionId() const;
+    String sessionId() const;
 
     void setError(MediaKeyError*);
-    MediaKeyError* error() { return m_error.get(); }
-
-    void setKeys(MediaKeys* keys) { m_keys = keys; }
-    MediaKeys* keys() const { return m_keys; }
+    PassRefPtr<MediaKeyError> error() const;

[ddorwin, 2013/06/06 23:29:50]

abarth: Which way should we prefer?
I changed this to be like HTMLMediaElement, though I'm not sure which way is
"correct". Interestingly, the generated V8 code is different between the two
classes but did not change when I changed this line.

[abarth-chromium, 2013/06/07 00:08:23]

Do you mean between returning a MediaKeyError* and a PassRefPtr<MediaKeyError> ?
 We prefer MediaKeyError* in this case because we're not passing ownership of
the object.

[ddorwin, 2013/06/10 22:52:34]

Done.

Should we change HTMLMediaElement too?

 
     void generateKeyRequest(const String& mimeType, Uint8Array* initData);
     void update(Uint8Array* key, ExceptionCode&);
     void close();
 
     using RefCounted<MediaKeySession>::ref;
     using RefCounted<MediaKeySession>::deref;
 
     void enqueueEvent(PassRefPtr<Event>);
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyadded);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeyerror);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitkeymessage);
 
     virtual const AtomicString& interfaceName() const OVERRIDE;
     virtual ScriptExecutionContext* scriptExecutionContext() const OVERRIDE;
 
-protected:
-    MediaKeySession(ScriptExecutionContext*, MediaKeys*, const String& keySystem);
+private:
+    MediaKeySession(ScriptExecutionContext*, CDM&, MediaKeys*);
     void keyRequestTimerFired(Timer<MediaKeySession>*);
     void addKeyTimerFired(Timer<MediaKeySession>*);
 
-    MediaKeys* m_keys;
-    String m_keySystem;
-    String m_sessionId;
+    // CDMSessionClient
+    virtual void keyAdded() OVERRIDE;
+    virtual void keyError(MediaKeyError::Code, unsigned long systemCode) OVERRIDE;
+    virtual void keyMessage(const unsigned char* message, unsigned messageLength, const KURL& destinationURL) OVERRIDE;
+
+    const String m_keySystem;
     RefPtr<MediaKeyError> m_error;
     OwnPtr<GenericEventQueue> m_asyncEventQueue;
     OwnPtr<CDMSession> m_session;
+    // Used to remove the reference from the parent MediaKeys when close()'d.
+    MediaKeys* m_keys;
 
     struct PendingKeyRequest {
         PendingKeyRequest(const String& mimeType, Uint8Array* initData) : mimeType(mimeType), initData(initData) { }
         String mimeType;
         RefPtr<Uint8Array> initData;
     };
     Deque<PendingKeyRequest> m_pendingKeyRequests;
     Timer<MediaKeySession> m_keyRequestTimer;
 
     Deque<RefPtr<Uint8Array> > m_pendingKeys;
     Timer<MediaKeySession> m_addKeyTimer;
 
 private:
     virtual void refEventTarget() OVERRIDE { ref(); }
     virtual void derefEventTarget() OVERRIDE { deref(); }
 
     virtual EventTargetData* eventTargetData() OVERRIDE { return &m_eventTargetData; }
     virtual EventTargetData* ensureEventTargetData() OVERRIDE { return &m_eventTargetData; }
 
     EventTargetData m_eventTargetData;
 };
 
 }
 
 #endif // ENABLE(ENCRYPTED_MEDIA_V2)
 
 #endif // MediaKeySession_h