Remove platform/drm files.

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 16 matching lines @@
 #include "modules/encryptedmedia/MediaKeySession.h"
 
 #include "bindings/v8/ExceptionState.h"
 #include "core/events/Event.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/GenericEventQueue.h"
 #include "core/html/MediaKeyError.h"
 #include "modules/encryptedmedia/MediaKeyMessageEvent.h"
 #include "modules/encryptedmedia/MediaKeys.h"
 #include "platform/Logging.h"
-#include "platform/drm/ContentDecryptionModule.h"
+#include "public/platform/WebContentDecryptionModule.h"
+#include "public/platform/WebString.h"
+#include "public/platform/WebURL.h"
 
 namespace WebCore {
 
 PassOwnPtr<MediaKeySession::PendingAction> MediaKeySession::PendingAction::CreatePendingUpdate(PassRefPtr<Uint8Array> data)
 {
     return adoptPtr(new PendingAction(Update, data));

[acolwell GONE FROM CHROMIUM, 2014/03/04 00:39:26]

nit: Put an ASSERT(data) here since the code below appears to assume this is
always non-null.

[jrummell, 2014/03/04 01:13:28]

Done.

 }
 
 PassOwnPtr<MediaKeySession::PendingAction> MediaKeySession::PendingAction::CreatePendingRelease()
 {
     return adoptPtr(new PendingAction(Release, PassRefPtr<Uint8Array>()));
 }
 
 MediaKeySession::PendingAction::PendingAction(Type type, PassRefPtr<Uint8Array> data)
     : type(type)
     , data(data)
 {
 }
 
 MediaKeySession::PendingAction::~PendingAction()
 {
 }
 
-PassRefPtrWillBeRawPtr<MediaKeySession> MediaKeySession::create(ExecutionContext* context, ContentDecryptionModule* cdm, WeakPtr<MediaKeys> keys)
+PassRefPtrWillBeRawPtr<MediaKeySession> MediaKeySession::create(ExecutionContext* context, blink::WebContentDecryptionModule* cdm, WeakPtr<MediaKeys> keys)
 {
     RefPtrWillBeRawPtr<MediaKeySession> session(adoptRefWillBeRefCountedGarbageCollected(new MediaKeySession(context, cdm, keys)));
     session->suspendIfNeeded();
     return session.release();
 }
 
-MediaKeySession::MediaKeySession(ExecutionContext* context, ContentDecryptionModule* cdm, WeakPtr<MediaKeys> keys)
+MediaKeySession::MediaKeySession(ExecutionContext* context, blink::WebContentDecryptionModule* cdm, WeakPtr<MediaKeys> keys)
     : ActiveDOMObject(context)
     , m_keySystem(keys->keySystem())
     , m_asyncEventQueue(GenericEventQueue::create(this))
-    , m_session(cdm->createSession(this))
+    , m_session(adoptPtr(cdm->createSession(this)))
     , m_keys(keys)
     , m_isClosed(false)
     , m_actionTimer(this, &MediaKeySession::actionTimerFired)
 {
     WTF_LOG(Media, "MediaKeySession::MediaKeySession");
     ScriptWrappable::init(this);
     ASSERT(m_session);
 }
 
 MediaKeySession::~MediaKeySession()
 {
     m_session.clear();
     m_asyncEventQueue->cancelAllEvents();
 }
 
 void MediaKeySession::setError(MediaKeyError* error)
 {
     m_error = error;
 }
 
 String MediaKeySession::sessionId() const
 {
     return m_session->sessionId();
 }
 
 void MediaKeySession::initializeNewSession(const String& mimeType, const Uint8Array& initData)
 {
     ASSERT(!m_isClosed);
-    m_session->initializeNewSession(mimeType, initData);
+    m_session->initializeNewSession(mimeType, initData.data(), initData.length());
 }
 
 void MediaKeySession::update(Uint8Array* response, ExceptionState& exceptionState)
 {
     WTF_LOG(Media, "MediaKeySession::update");
     ASSERT(!m_isClosed);
 
     // From <https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#dom-update>:
     // The update(response) method must run the following steps:
     // 1. If response is null or an empty array, throw an INVALID_ACCESS_ERR
@@ skipping 39 matching lines @@
     while (!m_pendingActions.isEmpty()) {
         OwnPtr<PendingAction> pendingAction(m_pendingActions.takeFirst());
 
         switch (pendingAction->type) {
         case PendingAction::Update:
             // NOTE: Continued from step 3. of MediaKeySession::update()
             // 3.1. Let cdm be the cdm loaded in the MediaKeys constructor.
             // 3.2. Let request be null.
             // 3.3. Use cdm to execute the following steps:
             // 3.3.1 Process response.
-            m_session->update(*(pendingAction->data));
+            m_session->update(pendingAction->data->data(), pendingAction->data->length());
             break;
         case PendingAction::Release:
             // NOTE: Continued from step 3. of MediaKeySession::release().
             // 3.1 Let cdm be the cdm loaded in the MediaKeys constructor.
             // 3.2 Use cdm to execute the following steps:
             // 3.2.1 Process the release request.
             m_session->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 KURL& destinationURL)
+void MediaKeySession::message(const unsigned char* message, size_t messageLength, const blink::WebURL& destinationURL)
 {
     WTF_LOG(Media, "MediaKeySession::message");
 
     MediaKeyMessageEventInit init;
     init.bubbles = false;
     init.cancelable = false;
     init.message = Uint8Array::create(message, messageLength);
-    init.destinationURL = destinationURL;
+    init.destinationURL = destinationURL.string();
 
     RefPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(EventTypeNames::message, init);
     event->setTarget(this);
     m_asyncEventQueue->enqueueEvent(event.release());
 }
 
 void MediaKeySession::ready()
 {
     WTF_LOG(Media, "MediaKeySession::ready");
 
@@ skipping 15 matching lines @@
     m_isClosed = true;
 }
 
 // Queue a task to fire a simple event named keyadded at the MediaKeySession object.
 void MediaKeySession::error(MediaKeyErrorCode errorCode, unsigned long systemCode)
 {
     WTF_LOG(Media, "MediaKeySession::error: errorCode=%d, systemCode=%lu", errorCode, systemCode);
 
     MediaKeyError::Code mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;
     switch (errorCode) {
-    case UnknownError:
+    case MediaKeyErrorCodeUnknown:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;
         break;
-    case ClientError:
+    case MediaKeyErrorCodeClient:
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_CLIENT;
         break;
     }
 
     // 1. Create a new MediaKeyError object with the following attributes:
     //    code = the appropriate MediaKeyError code
     //    systemCode = a Key System-specific value, if provided, and 0 otherwise
     // 2. Set the MediaKeySession object's error attribute to the error object created in the previous step.
     m_error = MediaKeyError::create(mediaKeyErrorCode, systemCode);
 
@@ skipping 29 matching lines @@
     m_session.clear();
     m_isClosed = true;
 
     if (m_actionTimer.isActive())
         m_actionTimer.stop();
     m_pendingActions.clear();
     m_asyncEventQueue->close();
 }
 
 }