encryptedmedia: Replace wtf/Assertions.h macros in favor of base/logging.h macros

third_party/WebKit/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 35 matching lines @@
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebContentDecryptionModuleException.h"
 #include "public/platform/WebContentDecryptionModuleSession.h"
 #include "public/platform/WebEncryptedMediaKeyInformation.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "wtf/ASCIICType.h"
 #include <cmath>
 #include <limits>
 
+#define MEDIA_KEY_SESSION_LOG_LEVEL 3
+
 namespace {
 
 // Minimum and maximum length for session ids.
 enum {
     MinSessionIdLength = 1,
     MaxSessionIdLength = 512
 };
 
 } // namespace
 
@@ skipping 29 matching lines @@
     case WebEncryptedMediaKeyInformation::KeyStatus::OutputRestricted:
         return "output-restricted";
     case WebEncryptedMediaKeyInformation::KeyStatus::OutputDownscaled:
         return "output-downscaled";
     case WebEncryptedMediaKeyInformation::KeyStatus::StatusPending:
         return "status-pending";
     case WebEncryptedMediaKeyInformation::KeyStatus::InternalError:
         return "internal-error";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return "internal-error";
 }
 
 static ScriptPromise CreateRejectedPromiseNotCallable(ScriptState* scriptState)
 {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError, "The session is not callable."));
 }
 
 static ScriptPromise CreateRejectedPromiseAlreadyInitialized(ScriptState* scriptState)
@@ skipping 15 matching lines @@
 
     Type getType() const { return m_type; }
 
     const Persistent<ContentDecryptionModuleResult> result() const
     {
         return m_result;
     }
 
     DOMArrayBuffer* data() const
     {
-        ASSERT(m_type == GenerateRequest || m_type == Update);
+        DCHECK(m_type == GenerateRequest || m_type == Update);
         return m_data;
     }
 
     WebEncryptedMediaInitDataType initDataType() const
     {
-        ASSERT(m_type == GenerateRequest);
+        DCHECK_EQ(m_type, GenerateRequest);

[jrummell, 2016/05/23 22:53:56]

Typically the expected value is first, the variable second.

[Srirama, 2016/05/24 16:24:04]

Done.

         return m_initDataType;
     }
 
     const String& sessionId() const
     {
-        ASSERT(m_type == Load);
+        DCHECK_EQ(m_type, Load);
         return m_stringData;
     }
 
     static PendingAction* CreatePendingGenerateRequest(ContentDecryptionModuleResult* result, WebEncryptedMediaInitDataType initDataType, DOMArrayBuffer* initData)
     {
-        ASSERT(result);
-        ASSERT(initData);
+        DCHECK(result);
+        DCHECK(initData);
         return new PendingAction(GenerateRequest, result, initDataType, initData, String());
     }
 
     static PendingAction* CreatePendingLoadRequest(ContentDecryptionModuleResult* result, const String& sessionId)
     {
-        ASSERT(result);
+        DCHECK(result);
         return new PendingAction(Load, result, WebEncryptedMediaInitDataType::Unknown, nullptr, sessionId);
     }
 
     static PendingAction* CreatePendingUpdate(ContentDecryptionModuleResult* result, DOMArrayBuffer* data)
     {
-        ASSERT(result);
-        ASSERT(data);
+        DCHECK(result);
+        DCHECK(data);
         return new PendingAction(Update, result, WebEncryptedMediaInitDataType::Unknown, data, String());
     }
 
     static PendingAction* CreatePendingClose(ContentDecryptionModuleResult* result)
     {
-        ASSERT(result);
+        DCHECK(result);
         return new PendingAction(Close, result, WebEncryptedMediaInitDataType::Unknown, nullptr, String());
     }
 
     static PendingAction* CreatePendingRemove(ContentDecryptionModuleResult* result)
     {
-        ASSERT(result);
+        DCHECK(result);
         return new PendingAction(Remove, result, WebEncryptedMediaInitDataType::Unknown, nullptr, String());
     }
 
     ~PendingAction()
     {
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_result);
@@ skipping 31 matching lines @@
     }
 
     ~NewSessionResultPromise() override
     {
     }
 
     // ContentDecryptionModuleResult implementation.
     void completeWithSession(WebContentDecryptionModuleResult::SessionStatus status) override
     {
         if (status != WebContentDecryptionModuleResult::NewSession) {
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             reject(InvalidStateError, "Unexpected completion.");
         }
 
         m_session->finishGenerateRequest();
         resolve();
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_session);
@@ skipping 28 matching lines @@
         case WebContentDecryptionModuleResult::NewSession:
             m_session->finishLoad();
             resolve(true);
             return;
 
         case WebContentDecryptionModuleResult::SessionNotFound:
             resolve(false);
             return;
 
         case WebContentDecryptionModuleResult::SessionAlreadyExists:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             reject(InvalidStateError, "Unexpected completion.");
             return;
         }
 
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_session);
         ContentDecryptionModuleResultPromise::trace(visitor);
     }
 
 private:
     Member<MediaKeySession> m_session;
@@ skipping 13 matching lines @@
     , m_mediaKeys(mediaKeys)
     , m_sessionType(sessionType)
     , m_expiration(std::numeric_limits<double>::quiet_NaN())
     , m_keyStatusesMap(new MediaKeyStatusMap())
     , m_isUninitialized(true)
     , m_isCallable(false)
     , m_isClosed(false)
     , m_closedPromise(new ClosedPromise(scriptState->getExecutionContext(), this, ClosedPromise::Closed))
     , m_actionTimer(this, &MediaKeySession::actionTimerFired)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::MediaKeySession", this);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "MediaKeySession(" << this << ")";

[jrummell, 2016/05/23 22:53:56]

To keep the message consistent I think this needs to be "std::hex << this <<
std::dec". Maybe overload operator<< to return "MediaKeySession(xxxx)::" and
then use << this << __FUNCTION__?

[Srirama, 2016/05/24 16:24:04]

DVLOG already prints filename and line number, so do we need "MediaKeySession::"
to be printed? We are just printing function name in HTMLMedia* file and other
media files. So i think __FUNCTION__ is good enough. WDYT?

[jrummell, 2016/05/24 18:07:11]

Acknowledged.

     ThreadState::current()->registerPreFinalizer(this);
 
     // Create the matching Chromium object. It will not be usable until
     // initializeNewSession() is called in response to the user calling
     // generateRequest().
     WebContentDecryptionModule* cdm = mediaKeys->contentDecryptionModule();
     m_session = adoptPtr(cdm->createSession());
     m_session->setClientInterface(this);
 
     // From https://w3c.github.io/encrypted-media/#createSession:
     // MediaKeys::createSession(), step 3.
     // 3.1 Let the sessionId attribute be the empty string.
-    ASSERT(sessionId().isEmpty());
+    DCHECK(sessionId().isEmpty());
 
     // 3.2 Let the expiration attribute be NaN.
-    ASSERT(std::isnan(m_expiration));
+    DCHECK(std::isnan(m_expiration));
 
     // 3.3 Let the closed attribute be a new promise.
-    ASSERT(!closed(scriptState).isUndefinedOrNull());
+    DCHECK(!closed(scriptState).isUndefinedOrNull());
 
     // 3.4 Let the keyStatuses attribute be empty.
-    ASSERT(m_keyStatusesMap->size() == 0);
+    DCHECK_EQ(m_keyStatusesMap->size(), 0u);
 
     // 3.5 Let the session type be sessionType.
-    ASSERT(m_sessionType != WebEncryptedMediaSessionType::Unknown);
+    DCHECK(m_sessionType != WebEncryptedMediaSessionType::Unknown);
 
     // 3.6 Let uninitialized be true.
-    ASSERT(m_isUninitialized);
+    DCHECK(m_isUninitialized);
 
     // 3.7 Let callable be false.
-    ASSERT(!m_isCallable);
+    DCHECK(!m_isCallable);
 
     // 3.8 Let the use distinctive identifier value be this object's
     // use distinctive identifier.
     // FIXME: Implement this (http://crbug.com/448922).
 
     // 3.9 Let the cdm implementation value be this object's cdm implementation.
     // 3.10 Let the cdm instance value be this object's cdm instance.
 }
 
 MediaKeySession::~MediaKeySession()
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::~MediaKeySession", this);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "~MediaKeySession(" << this << ")";
 }
 
 void MediaKeySession::dispose()
 {
     // Promptly clears a raw reference from content/ to an on-heap object
     // so that content/ doesn't access it in a lazy sweeping phase.
     m_session.clear();
 }
 
 String MediaKeySession::sessionId() const
 {
     return m_session->sessionId();
 }
 
 ScriptPromise MediaKeySession::closed(ScriptState* scriptState)
 {
     return m_closedPromise->promise(scriptState->world());
 }
 
 MediaKeyStatusMap* MediaKeySession::keyStatuses()
 {
     return m_keyStatusesMap;
 }
 
 ScriptPromise MediaKeySession::generateRequest(ScriptState* scriptState, const String& initDataTypeString, const DOMArrayPiece& initData)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::generateRequest %s", this, initDataTypeString.ascii().data());
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "generateRequest(" << this << ") " << initDataTypeString;
 
     // From https://w3c.github.io/encrypted-media/#generateRequest:
     // Generates a request based on the initData. When this method is invoked,
     // the user agent must run the following steps:
 
     // 1. If this object's uninitialized value is false, return a promise
     //    rejected with a new DOMException whose name is "InvalidStateError".
     if (!m_isUninitialized)
         return CreateRejectedPromiseAlreadyInitialized(scriptState);
 
@@ skipping 34 matching lines @@
     // 7. Let session type be this object's session type.
     //    (Done in constructor.)
 
     // 8. Let promise be a new promise.
     NewSessionResultPromise* result = new NewSessionResultPromise(scriptState, this);
     ScriptPromise promise = result->promise();
 
     // 9. Run the following steps asynchronously (documented in
     //    actionTimerFired())
     m_pendingActions.append(PendingAction::CreatePendingGenerateRequest(result, initDataType, initDataBuffer));
-    ASSERT(!m_actionTimer.isActive());
+    DCHECK(!m_actionTimer.isActive());
     m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
     // 10. Return promise.
     return promise;
 }
 
 ScriptPromise MediaKeySession::load(ScriptState* scriptState, const String& sessionId)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::load %s", this, sessionId.ascii().data());
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "load(" << this << ") " << sessionId;
 
     // From https://w3c.github.io/encrypted-media/#load:
     // Loads the data stored for the specified session into this object. When
     // this method is invoked, the user agent must run the following steps:
 
     // 1. If this object's uninitialized value is false, return a promise
     //    rejected with a new DOMException whose name is "InvalidStateError".
     if (!m_isUninitialized)
         return CreateRejectedPromiseAlreadyInitialized(scriptState);
 
@@ skipping 24 matching lines @@
     // 6. Let origin be the origin of this object's Document.
     //    (Available as getExecutionContext()->getSecurityOrigin() anytime.)
 
     // 7. Let promise be a new promise.
     LoadSessionResultPromise* result = new LoadSessionResultPromise(scriptState, this);
     ScriptPromise promise = result->promise();
 
     // 8. Run the following steps asynchronously (documented in
     //    actionTimerFired())
     m_pendingActions.append(PendingAction::CreatePendingLoadRequest(result, sessionId));
-    ASSERT(!m_actionTimer.isActive());
+    DCHECK(!m_actionTimer.isActive());
     m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
     // 9. Return promise.
     return promise;
 }
 
 ScriptPromise MediaKeySession::update(ScriptState* scriptState, const DOMArrayPiece& response)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::update", this);
-    ASSERT(!m_isClosed);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "update(" << this << ")";
+    DCHECK(!m_isClosed);
 
     // From https://w3c.github.io/encrypted-media/#update:
     // Provides messages, including licenses, to the CDM. When this method is
     // invoked, the user agent must run the following steps:
 
     // 1. If this object's callable value is false, return a promise rejected
     //    with a new DOMException whose name is InvalidStateError.
     if (!m_isCallable)
         return CreateRejectedPromiseNotCallable(scriptState);
 
@@ skipping 16 matching lines @@
     m_pendingActions.append(PendingAction::CreatePendingUpdate(result, responseCopy));
     if (!m_actionTimer.isActive())
         m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
     // 6. Return promise.
     return promise;
 }
 
 ScriptPromise MediaKeySession::close(ScriptState* scriptState)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::close", this);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "close(" << this << ")";
 
     // From https://w3c.github.io/encrypted-media/#close:
     // Indicates that the application no longer needs the session and the CDM
     // should release any resources associated with this object and close it.
     // When this method is invoked, the user agent must run the following steps:
 
     // 1. If this object's callable value is false, return a promise rejected
     //    with a new DOMException whose name is "InvalidStateError".
     if (!m_isCallable)
         return CreateRejectedPromiseNotCallable(scriptState);
@@ skipping 12 matching lines @@
     m_pendingActions.append(PendingAction::CreatePendingClose(result));
     if (!m_actionTimer.isActive())
         m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
     // 5. Return promise.
     return promise;
 }
 
 ScriptPromise MediaKeySession::remove(ScriptState* scriptState)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::remove", this);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "remove(" << this << ")";
 
     // From https://w3c.github.io/encrypted-media/#remove:
     // Removes stored session data associated with this object. When this
     // method is invoked, the user agent must run the following steps:
 
     // 1. If this object's callable value is false, return a promise rejected
     //    with a new DOMException whose name is "InvalidStateError".
     if (!m_isCallable)
         return CreateRejectedPromiseNotCallable(scriptState);
 
@@ skipping 22 matching lines @@
     m_pendingActions.append(PendingAction::CreatePendingRemove(result));
     if (!m_actionTimer.isActive())
         m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
     // 6. Return promise.
     return promise;
 }
 
 void MediaKeySession::actionTimerFired(Timer<MediaKeySession>*)
 {
-    ASSERT(m_pendingActions.size());
+    DCHECK(m_pendingActions.size());
 
     // Resolving promises now run synchronously and may result in additional
     // actions getting added to the queue. As a result, swap the queue to
     // a local copy to avoid problems if this happens.
     HeapDeque<Member<PendingAction>> pendingActions;
     pendingActions.swap(m_pendingActions);
 
     while (!pendingActions.isEmpty()) {
         PendingAction* action = pendingActions.takeFirst();
 
         switch (action->getType()) {
         case PendingAction::GenerateRequest:
             // NOTE: Continue step 9 of MediaKeySession::generateRequest().
-            WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: GenerateRequest", this);
+            DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "actionTimerFired(" << this << ") GenerateRequest";
 
             // initializeNewSession() in Chromium will execute steps 9.1 to 9.7.
             m_session->initializeNewSession(action->initDataType(), static_cast<unsigned char*>(action->data()->data()), action->data()->byteLength(), m_sessionType, action->result()->result());
 
             // Remaining steps (from 9.8) executed in finishGenerateRequest(),
             // called when |result| is resolved.
             break;
 
         case PendingAction::Load:
             // NOTE: Continue step 8 of MediaKeySession::load().
-            WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Load", this);
+            DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "actionTimerFired(" << this << ") Load";
 
             // 8.1 Let sanitized session ID be a validated and/or sanitized
             //     version of sessionId. The user agent should thoroughly
             //     validate the sessionId value before passing it to the CDM.
             //     At a minimum, this should include checking that the length
             //     and value (e.g. alphanumeric) are reasonable.
             // 8.2 If the previous step failed, reject promise with a new
             //     DOMException whose name is "InvalidAccessError".
             if (!isValidSessionId(action->sessionId())) {
                 action->result()->completeWithError(WebContentDecryptionModuleExceptionInvalidAccessError, 0, "Invalid sessionId");
                 return;
             }
 
             // 8.3 If there is an unclosed session in the object's Document
             //     whose sessionId attribute is sanitized session ID, reject
             //     promise with a new DOMException whose name is
             //     QuotaExceededError. In other words, do not create a session
             //     if a non-closed session, regardless of type, already exists
             //     for this sanitized session ID in this browsing context.
             //     (Done in the CDM.)
 
             // 8.4 Let expiration time be NaN.
             //     (Done in the constructor.)
-            ASSERT(std::isnan(m_expiration));
+            DCHECK(std::isnan(m_expiration));
 
             // load() in Chromium will execute steps 8.5 through 8.8.
             m_session->load(action->sessionId(), action->result()->result());
 
             // Remaining steps (from 8.9) executed in finishLoad(), called
             // when |result| is resolved.
             break;
 
         case PendingAction::Update:
             // NOTE: Continue step 5 of MediaKeySession::update().
-            WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Update", this);
+            DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "actionTimerFired(" << this << ") Update";
 
             // update() in Chromium will execute steps 5.1 through 5.8.
             m_session->update(static_cast<unsigned char*>(action->data()->data()), action->data()->byteLength(), action->result()->result());
 
             // Last step (5.9 Resolve promise) will be done when |result| is
             // resolved.
             break;
 
         case PendingAction::Close:
             // NOTE: Continue step 4 of MediaKeySession::close().
-            WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Close", this);
+            DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "actionTimerFired(" << this << ") Close";
 
             // close() in Chromium will execute steps 4.1 through 4.2.
             m_session->close(action->result()->result());
 
             // Last step (4.3 Resolve promise) will be done when |result| is
             // resolved.
             break;
 
         case PendingAction::Remove:
             // NOTE: Continue step 5 of MediaKeySession::remove().
-            WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Remove", this);
+            DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "actionTimerFired(" << this << ") Remove";
 
             // remove() in Chromium will execute steps 5.1 through 5.3.
             m_session->remove(action->result()->result());
 
             // Last step (5.3.3 Resolve promise) will be done when |result| is
             // resolved.
             break;
         }
     }
 }
 
 void MediaKeySession::finishGenerateRequest()
 {
     // 9.8 If any of the preceding steps failed, reject promise with a
     //     new DOMException whose name is the appropriate error name.
     //     (Done by CDM calling result.completeWithError() as appropriate.)
 
     // 9.9 Set the sessionId attribute to session id.
-    ASSERT(!sessionId().isEmpty());
+    DCHECK(!sessionId().isEmpty());
 
     // 9.10 Let this object's callable be true.
     m_isCallable = true;
 
     // 9.11 Run the queue a "message" event algorithm on the session,
     //      providing "license-request" and message.
     //     (Done by the CDM.)
 
     // 9.12 Resolve promise.
     //      (Done by NewSessionResultPromise.)
 }
 
 void MediaKeySession::finishLoad()
 {
     // 8.9 If any of the preceding steps failed, reject promise with a new
     //     DOMException whose name is the appropriate error name.
     //     (Done by CDM calling result.completeWithError() as appropriate.)
 
     // 8.10 Set the sessionId attribute to sanitized session ID.
-    ASSERT(!sessionId().isEmpty());
+    DCHECK(!sessionId().isEmpty());
 
     // 8.11 Let this object's callable be true.
     m_isCallable = true;
 
     // 8.12 If the loaded session contains information about any keys (there
     //      are known keys), run the update key statuses algorithm on the
     //      session, providing each key's key ID along with the appropriate
     //      MediaKeyStatus. Should additional processing be necessary to
     //      determine with certainty the status of a key, use the non-"usable"
     //      MediaKeyStatus value that corresponds to the reason for the
@@ skipping 10 matching lines @@
     //      on the session, providing message type and message.
     //      (Done by the CDM.)
 
     // 8.15 Resolve promise with true.
     //      (Done by LoadSessionResultPromise.)
 }
 
 // Queue a task to fire a simple event named keymessage at the new object.
 void MediaKeySession::message(MessageType messageType, const unsigned char* message, size_t messageLength)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::message", this);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "message(" << this << ")";
 
     // Verify that 'message' not fired before session initialization is complete.
-    ASSERT(m_isCallable);
+    DCHECK(m_isCallable);
 
     // From https://w3c.github.io/encrypted-media/#queue-message:
     // The following steps are run:
     // 1. Let the session be the specified MediaKeySession object.
     // 2. Queue a task to fire a simple event named message at the session.
     //    The event is of type MediaKeyMessageEvent and has:
     //    -> messageType = the specified message type
     //    -> message = the specified message
 
     MediaKeyMessageEventInit init;
@@ skipping 10 matching lines @@
     }
     init.setMessage(DOMArrayBuffer::create(static_cast<const void*>(message), messageLength));
 
     MediaKeyMessageEvent* event = MediaKeyMessageEvent::create(EventTypeNames::message, init);
     event->setTarget(this);
     m_asyncEventQueue->enqueueEvent(event);
 }
 
 void MediaKeySession::close()
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::close", this);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "close(" << this << ")";
 
     // From https://w3c.github.io/encrypted-media/#session-close:
     // The following steps are run:
     // 1. Let the session be the associated MediaKeySession object.
     // 2. Let promise be the closed attribute of the session.
     // 3. Resolve promise.
     m_closedPromise->resolve(ToV8UndefinedGenerator());
 
     // Once closed, the session can no longer be the target of events from
     // the CDM so this object can be garbage collected.
     m_isClosed = true;
 }
 
 void MediaKeySession::expirationChanged(double updatedExpiryTimeInMS)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::expirationChanged %f", this, updatedExpiryTimeInMS);
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "expirationChanged(" << this << ") " << updatedExpiryTimeInMS;
 
     // From https://w3c.github.io/encrypted-media/#update-expiration:
     // The following steps are run:
     // 1. Let the session be the associated MediaKeySession object.
     // 2. Let expiration time be NaN.
     double expirationTime = std::numeric_limits<double>::quiet_NaN();
 
     // 3. If the new expiration time is not NaN, let expiration time be the
     //    new expiration time in milliseconds since 01 January 1970 UTC.
     //    (Note that Chromium actually passes 0 to indicate no expiry.)
     // FIXME: Get Chromium to pass NaN.
     if (!std::isnan(updatedExpiryTimeInMS) && updatedExpiryTimeInMS != 0.0)
         expirationTime = updatedExpiryTimeInMS;
 
     // 4. Set the session's expiration attribute to expiration time.
     m_expiration = expirationTime;
 }
 
 void MediaKeySession::keysStatusesChange(const WebVector<WebEncryptedMediaKeyInformation>& keys, bool hasAdditionalUsableKey)
 {
-    WTF_LOG(Media, "MediaKeySession(%p)::keysStatusesChange with %zu keys and hasAdditionalUsableKey is %s", this, keys.size(), hasAdditionalUsableKey ? "true" : "false");
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "keysStatusesChange(" << this << ") with " << keys.size() << " keys and hasAdditionalUsableKey is " << (hasAdditionalUsableKey ? "true" : "false");
 
     // From https://w3c.github.io/encrypted-media/#update-key-statuses:
     // The following steps are run:
     // 1. Let the session be the associated MediaKeySession object.
     // 2. Let the input statuses be the sequence of pairs key ID and
     //    associated MediaKeyStatus pairs.
     // 3. Let the statuses be session's keyStatuses attribute.
 
     // 4. Run the following steps to replace the contents of statuses:
     // 4.1 Empty statuses.
@@ skipping 29 matching lines @@
 
 ExecutionContext* MediaKeySession::getExecutionContext() const
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 bool MediaKeySession::hasPendingActivity() const
 {
     // Remain around if there are pending events or MediaKeys is still around
     // and we're not closed.
-    WTF_LOG(Media, "MediaKeySession(%p)::hasPendingActivity %s%s%s", this,
-        !m_pendingActions.isEmpty() ? " !m_pendingActions.isEmpty()" : "",
-        m_asyncEventQueue->hasPendingEvents() ? " m_asyncEventQueue->hasPendingEvents()" : "",
-        (m_mediaKeys && !m_isClosed) ? " m_mediaKeys && !m_isClosed" : "");
+    DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << "hasPendingActivity(" << this << ") "
+        << (!m_pendingActions.isEmpty() ? " !m_pendingActions.isEmpty()" : "")
+        << (m_asyncEventQueue->hasPendingEvents() ? " m_asyncEventQueue->hasPendingEvents()" : "")
+        << ((m_mediaKeys && !m_isClosed) ? " m_mediaKeys && !m_isClosed" : "");
 
     return !m_pendingActions.isEmpty()
         || m_asyncEventQueue->hasPendingEvents()
         || (m_mediaKeys && !m_isClosed);
 }
 
 void MediaKeySession::stop()
 {
     // Stop the CDM from firing any more events for this session.
     m_session.clear();
@@ skipping 10 matching lines @@
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_pendingActions);
     visitor->trace(m_mediaKeys);
     visitor->trace(m_keyStatusesMap);
     visitor->trace(m_closedPromise);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink