Use __func__ instead of __FUNCTION__.

third_party/WebKit/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 "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"
@@ skipping 100 matching lines @@
     return handler->promise();
 }
 
 SetMediaKeysHandler::SetMediaKeysHandler(ScriptState* scriptState, HTMLMediaElement& element, MediaKeys* mediaKeys)
     : ScriptPromiseResolver(scriptState)
     , m_element(element)
     , m_newMediaKeys(mediaKeys)
     , m_madeReservation(false)
     , m_timer(this, &SetMediaKeysHandler::timerFired)
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
 
     // 5. Run the following steps in parallel.
     m_timer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 SetMediaKeysHandler::~SetMediaKeysHandler()
 {
 }
 
 void SetMediaKeysHandler::timerFired(Timer<SetMediaKeysHandler>*)
 {
     clearExistingMediaKeys();
 }
 
 void SetMediaKeysHandler::clearExistingMediaKeys()
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(*m_element);
 
     // 5.1 If mediaKeys is not null, the CDM instance represented by
     //     mediaKeys is already in use by another media element, and
     //     the user agent is unable to use it with this element, let
     //     this object's attaching media keys value be false and
     //     reject promise with a QuotaExceededError.
     if (m_newMediaKeys) {
         if (!m_newMediaKeys->reserveForMediaElement(m_element.get())) {
             thisElement.m_isAttachingMediaKeys = false;
@@ skipping 28 matching lines @@
             return;
         }
     }
 
     // MediaKeys not currently set or no player connected, so continue on.
     setNewMediaKeys();
 }
 
 void SetMediaKeysHandler::setNewMediaKeys()
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
 
     // 5.3 If mediaKeys is not null, run the following steps:
     if (m_newMediaKeys) {
         // 5.3.1 Associate the CDM instance represented by mediaKeys with the
         //       media element for decrypting media data.
         // 5.3.2 If the preceding step failed, run the following steps:
         //       (done in setFailed()).
         // 5.3.3 Queue a task to run the Attempt to Resume Playback If Necessary
         //       algorithm on the media element.
         //       (Handled in Chromium).
         if (m_element->webMediaPlayer()) {
             std::unique_ptr<SuccessCallback> successCallback = WTF::bind(&SetMediaKeysHandler::finish, wrapPersistent(this));
             std::unique_ptr<FailureCallback> failureCallback = WTF::bind(&SetMediaKeysHandler::setFailed, wrapPersistent(this));
             ContentDecryptionModuleResult* result = new SetContentDecryptionModuleResult(std::move(successCallback), std::move(failureCallback));
             m_element->webMediaPlayer()->setContentDecryptionModule(m_newMediaKeys->contentDecryptionModule(), result->result());
 
             // Don't do anything more until |result| is resolved (or rejected).
             return;
         }
     }
 
     // MediaKeys doesn't need to be set on the player, so continue on.
     finish();
 }
 
 void SetMediaKeysHandler::finish()
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(*m_element);
 
     // 5.4 Set the mediaKeys attribute to mediaKeys.
     if (thisElement.m_mediaKeys)
         thisElement.m_mediaKeys->clearMediaElement();
     thisElement.m_mediaKeys = m_newMediaKeys;
     if (m_madeReservation)
         m_newMediaKeys->acceptReservation();
 
     // 5.5 Let this object's attaching media keys value be false.
@@ skipping 11 matching lines @@
 
     // Make sure attaching media keys value is false.
     DCHECK(!HTMLMediaElementEncryptedMedia::from(*m_element).m_isAttachingMediaKeys);
 
     // Reject promise with an appropriate error.
     reject(DOMException::create(code, errorMessage));
 }
 
 void SetMediaKeysHandler::clearFailed(ExceptionCode code, const String& errorMessage)
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__ << "(" << code << ", " << errorMessage << ")";
+    DVLOG(EME_LOG_LEVEL) << __func__ << "(" << code << ", " << errorMessage << ")";
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(*m_element);
 
     // 5.2.4 If the preceding step failed, let this object's attaching media
     //      keys value be false and reject promise with an appropriate
     //      error name.
     thisElement.m_isAttachingMediaKeys = false;
     fail(code, errorMessage);
 }
 
 void SetMediaKeysHandler::setFailed(ExceptionCode code, const String& errorMessage)
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__ << "(" << code << ", " << errorMessage << ")";
+    DVLOG(EME_LOG_LEVEL) << __func__ << "(" << code << ", " << errorMessage << ")";
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(*m_element);
 
     // 5.3.2 If the preceding step failed (in setContentDecryptionModule()
     //       called from setNewMediaKeys()), run the following steps:
     // 5.3.2.1 Set the mediaKeys attribute to null.
     thisElement.m_mediaKeys.clear();
 
     // 5.3.2.2 Let this object's attaching media keys value be false.
     thisElement.m_isAttachingMediaKeys = false;
 
@@ skipping 11 matching lines @@
 
 HTMLMediaElementEncryptedMedia::HTMLMediaElementEncryptedMedia(HTMLMediaElement& element)
     : m_mediaElement(&element)
     , m_isWaitingForKey(false)
     , m_isAttachingMediaKeys(false)
 {
 }
 
 HTMLMediaElementEncryptedMedia::~HTMLMediaElementEncryptedMedia()
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
 }
 
 const char* HTMLMediaElementEncryptedMedia::supplementName()
 {
     return "HTMLMediaElementEncryptedMedia";
 }
 
 HTMLMediaElementEncryptedMedia& HTMLMediaElementEncryptedMedia::from(HTMLMediaElement& element)
 {
     HTMLMediaElementEncryptedMedia* supplement = static_cast<HTMLMediaElementEncryptedMedia*>(Supplement<HTMLMediaElement>::from(element, supplementName()));
     if (!supplement) {
         supplement = new HTMLMediaElementEncryptedMedia(element);
         provideTo(element, supplementName(), supplement);
     }
     return *supplement;
 }
 
 MediaKeys* HTMLMediaElementEncryptedMedia::mediaKeys(HTMLMediaElement& element)
 {
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
     return thisElement.m_mediaKeys.get();
 }
 
 ScriptPromise HTMLMediaElementEncryptedMedia::setMediaKeys(ScriptState* scriptState, HTMLMediaElement& element, MediaKeys* mediaKeys)
 {
     HTMLMediaElementEncryptedMedia& thisElement = HTMLMediaElementEncryptedMedia::from(element);
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__ << " current(" << thisElement.m_mediaKeys.get() << "), new(" << mediaKeys << ")";
+    DVLOG(EME_LOG_LEVEL) << __func__ << " current(" << thisElement.m_mediaKeys.get() << "), new(" << mediaKeys << ")";
 
     // From http://w3c.github.io/encrypted-media/#setMediaKeys
 
     // 1. If mediaKeys and the mediaKeys attribute are the same object,
     //    return a resolved promise.
     if (thisElement.m_mediaKeys == mediaKeys)
         return ScriptPromise::castUndefined(scriptState);
 
     // 2. If this object's attaching media keys value is true, return a
     //    promise rejected with an InvalidStateError.
@@ skipping 16 matching lines @@
     initializer.setInitDataType(EncryptedMediaUtils::convertFromInitDataType(initDataType));
     initializer.setInitData(DOMArrayBuffer::create(initData, initDataLength));
     initializer.setBubbles(false);
     initializer.setCancelable(false);
 
     return MediaEncryptedEvent::create(EventTypeNames::encrypted, initializer);
 }
 
 void HTMLMediaElementEncryptedMedia::encrypted(WebEncryptedMediaInitDataType initDataType, const unsigned char* initData, unsigned initDataLength)
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
 
     Event* event;
     if (m_mediaElement->isMediaDataCORSSameOrigin(m_mediaElement->getExecutionContext()->getSecurityOrigin())) {
         event = createEncryptedEvent(initDataType, initData, initDataLength);
     } else {
         // Current page is not allowed to see content from the media file,
         // so don't return the initData. However, they still get an event.
         event = createEncryptedEvent(WebEncryptedMediaInitDataType::Unknown, nullptr, 0);
     }
 
     event->setTarget(m_mediaElement);
     m_mediaElement->scheduleEvent(event);
 }
 
 void HTMLMediaElementEncryptedMedia::didBlockPlaybackWaitingForKey()
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
 
     // From https://w3c.github.io/encrypted-media/#queue-waitingforkey:
     // It should only be called when the HTMLMediaElement object is potentially
     // playing and its readyState is equal to HAVE_FUTURE_DATA or greater.
     // FIXME: Is this really required?
 
     // 1. Let the media element be the specified HTMLMediaElement object.
     // 2. If the media element's waiting for key value is false, queue a task
     //    to fire a simple event named waitingforkey at the media element.
     if (!m_isWaitingForKey) {
         Event* event = Event::create(EventTypeNames::waitingforkey);
         event->setTarget(m_mediaElement);
         m_mediaElement->scheduleEvent(event);
     }
 
     // 3. Set the media element's waiting for key value to true.
     m_isWaitingForKey = true;
 
     // 4. Suspend playback.
     //    (Already done on the Chromium side by the decryptors.)
 }
 
 void HTMLMediaElementEncryptedMedia::didResumePlaybackBlockedForKey()
 {
-    DVLOG(EME_LOG_LEVEL) << __FUNCTION__;
+    DVLOG(EME_LOG_LEVEL) << __func__;
 
     // Logic is on the Chromium side to attempt to resume playback when a new
     // key is available. However, |m_isWaitingForKey| needs to be cleared so
     // that a later waitingForKey() call can generate the event.
     m_isWaitingForKey = false;
 }
 
 WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionModule()
 {
     return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0;
 }
 
 DEFINE_TRACE(HTMLMediaElementEncryptedMedia)
 {
     visitor->trace(m_mediaElement);
     visitor->trace(m_mediaKeys);
     Supplement<HTMLMediaElement>::trace(visitor);
 }
 
 } // namespace blink