Rename Blink constants generated from IDL files.

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 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 388 matching lines @@
     , ActiveScriptWrappable(this)
     , ActiveDOMObject(&document)
     , m_loadTimer(this, &HTMLMediaElement::loadTimerFired)
     , m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired)
     , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)
     , m_audioTracksTimer(this, &HTMLMediaElement::audioTracksTimerFired)
     , m_playedTimeRanges()
     , m_asyncEventQueue(GenericEventQueue::create(this))
     , m_playbackRate(1.0f)
     , m_defaultPlaybackRate(1.0f)
-    , m_networkState(NETWORK_EMPTY)
-    , m_readyState(HAVE_NOTHING)
-    , m_readyStateMaximum(HAVE_NOTHING)
+    , m_networkState(kNetworkEmpty)
+    , m_readyState(kHaveNothing)
+    , m_readyStateMaximum(kHaveNothing)
     , m_volume(1.0f)
     , m_lastSeekTime(0)
     , m_previousProgressTime(std::numeric_limits<double>::max())
     , m_duration(std::numeric_limits<double>::quiet_NaN())
     , m_lastTimeUpdateEventWallTime(0)
     , m_lastTimeUpdateEventMovieTime(0)
     , m_defaultPlaybackStartPosition(0)
     , m_loadState(WaitingForSource)
     , m_deferredLoadState(NotDeferred)
     , m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired)
@@ skipping 170 matching lines @@
     return new LayoutMedia(this);
 }
 
 Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(ContainerNode* insertionPoint)
 {
     BLINK_MEDIA_LOG << "insertedInto(" << (void*)this << ", " << insertionPoint << ")";
 
     HTMLElement::insertedInto(insertionPoint);
     if (insertionPoint->isConnected()) {
         UseCounter::count(document(), UseCounter::HTMLMediaElementInDocument);
-        if ((!getAttribute(srcAttr).isEmpty() || m_srcObject) && m_networkState == NETWORK_EMPTY) {
+        if ((!getAttribute(srcAttr).isEmpty() || m_srcObject) && m_networkState == kNetworkEmpty) {
             m_ignorePreloadNone = false;
             invokeLoadAlgorithm();
         }
     }
 
     return InsertionShouldCallDidNotifySubtreeInsertions;
 }
 
 void HTMLMediaElement::didNotifySubtreeInsertionsToDocument()
 {
     configureMediaControls();
 }
 
 void HTMLMediaElement::removedFrom(ContainerNode* insertionPoint)
 {
     BLINK_MEDIA_LOG << "removedFrom(" << (void*)this << ", " << insertionPoint << ")";
 
     HTMLElement::removedFrom(insertionPoint);
     if (insertionPoint->inActiveDocument()) {
         configureMediaControls();
-        if (m_networkState > NETWORK_EMPTY)
+        if (m_networkState > kNetworkEmpty)
             pauseInternal();
     }
 }
 
 void HTMLMediaElement::attachLayoutTree(const AttachContext& context)
 {
     HTMLElement::attachLayoutTree(context);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
@@ skipping 128 matching lines @@
     m_currentSourceNode = nullptr;
 
     // 2 - If there are any tasks from the media element's media element event task source in
     // one of the task queues, then remove those tasks.
     cancelPendingEventsAndCallbacks();
 
     rejectPlayPromises(AbortError, "The play() request was interrupted by a new load request.");
 
     // 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue
     // a task to fire a simple event named abort at the media element.
-    if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)
+    if (m_networkState == kNetworkLoading || m_networkState == kNetworkIdle)
         scheduleEvent(EventTypeNames::abort);
 
     resetMediaPlayerAndMediaSource();
 
     // 4 - If the media element's networkState is not set to NETWORK_EMPTY, then run these substeps
-    if (m_networkState != NETWORK_EMPTY) {
+    if (m_networkState != kNetworkEmpty) {
         // 4.1 - Queue a task to fire a simple event named emptied at the media element.
         scheduleEvent(EventTypeNames::emptied);
 
         // 4.2 - If a fetching process is in progress for the media element, the user agent should stop it.
-        setNetworkState(NETWORK_EMPTY);
+        setNetworkState(kNetworkEmpty);
 
         // 4.3 - Forget the media element's media-resource-specific tracks.
         forgetResourceSpecificTracks();
 
         // 4.4 - If readyState is not set to HAVE_NOTHING, then set it to that state.
-        m_readyState = HAVE_NOTHING;
-        m_readyStateMaximum = HAVE_NOTHING;
+        m_readyState = kHaveNothing;
+        m_readyStateMaximum = kHaveNothing;
 
         // 4.5 - If the paused attribute is false, then set it to true.
         m_paused = true;
 
         // 4.6 - If seeking is true, set it to false.
         m_seeking = false;
 
         // 4.7 - Set the current playback position to 0.
         //       Set the official playback position to 0.
         //       If this changed the official playback position, then queue a task to fire a simple event named timeupdate at the media element.
         // FIXME: Add support for firing this event.
 
         // 4.8 - Set the initial playback position to 0.
-        // FIXME: Make this less subtle. The position only becomes 0 because the ready state is HAVE_NOTHING.
+        // FIXME: Make this less subtle. The position only becomes 0 because the ready state is kHaveNothing.
         invalidateCachedTime();
 
         // 4.9 - Set the timeline offset to Not-a-Number (NaN).
         // 4.10 - Update the duration attribute to Not-a-Number (NaN).
 
         cueTimeline().updateActiveCues(0);
     } else if (!m_paused) {
         // TODO(foolip): There is a proposal to always reset the paused state
         // in the media element load algorithm, to avoid a bogus play() promise
         // rejection: https://github.com/whatwg/html/issues/869
@@ skipping 13 matching lines @@
     invokeResourceSelectionAlgorithm();
 
     // 8 - Note: Playback of any previously playing media resource for this element stops.
 }
 
 void HTMLMediaElement::invokeResourceSelectionAlgorithm()
 {
     BLINK_MEDIA_LOG << "invokeResourceSelectionAlgorithm(" << (void*)this << ")";
     // The resource selection algorithm
     // 1 - Set the networkState to NETWORK_NO_SOURCE
-    setNetworkState(NETWORK_NO_SOURCE);
+    setNetworkState(kNetworkNoSource);
 
     // 2 - Set the element's show poster flag to true
     // TODO(srirama.m): Introduce show poster flag and update it as per spec
 
     m_playedTimeRanges = TimeRanges::create();
 
-    // FIXME: Investigate whether these can be moved into m_networkState != NETWORK_EMPTY block above
+    // FIXME: Investigate whether these can be moved into m_networkState != kNetworkEmpty block above
     // so they are closer to the relevant spec steps.
     m_lastSeekTime = 0;
     m_duration = std::numeric_limits<double>::quiet_NaN();
 
     // 3 - Set the media element's delaying-the-load-event flag to true (this delays the load event)
     setShouldDelayLoadEvent(true);
     if (mediaControls())
         mediaControls()->reset();
 
     // 4 - Await a stable state, allowing the task that invoked this algorithm to continue
@@ skipping 37 matching lines @@
         // Otherwise, if the media element does not have an assigned media
         // provider object and does not have a src attribute, but does have a
         // source element child, then let mode be children and let candidate be
         // the first such source element child in tree order.
         mode = Children;
         m_nextChildNodeToConsider = element;
         m_currentSourceNode = nullptr;
     } else {
         // Otherwise the media element has no assigned media provider object and
         // has neither a src attribute nor a source element child: set the
-        // networkState to NETWORK_EMPTY, and abort these steps; the synchronous
+        // networkState to kNetworkEmpty, and abort these steps; the synchronous
         // section ends.
         m_loadState = WaitingForSource;
         setShouldDelayLoadEvent(false);
-        setNetworkState(NETWORK_EMPTY);
+        setNetworkState(kNetworkEmpty);
         updateDisplayState();
 
         BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << "), nothing to load";
         return;
     }
 
     // 7 - Set the media element's networkState to NETWORK_LOADING.
-    setNetworkState(NETWORK_LOADING);
+    setNetworkState(kNetworkLoading);
 
     // 8 - Queue a task to fire a simple event named loadstart at the media element.
     scheduleEvent(EventTypeNames::loadstart);
 
     // 9 - Run the appropriate steps...
     switch (mode) {
     case Object:
         loadSourceFromObject();
         BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << ", using 'srcObject' attribute";
         break;
@@ skipping 69 matching lines @@
         BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ", " << urlForLoggingMedia(url) << ", " << contentType.raw() << ")";
     }
 
     LocalFrame* frame = document().frame();
     if (!frame) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // The resource fetch algorithm
-    setNetworkState(NETWORK_LOADING);
+    setNetworkState(kNetworkLoading);
 
     m_autoplayHelper->loadingStarted();
 
     // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
     // cache is an internal detail not exposed through the media element API.
     m_currentSrc = url;
 
     if (m_audioSourceNode)
         m_audioSourceNode->onCurrentSrcChanged(m_currentSrc);
 
@@ skipping 152 matching lines @@
 
     // resource fetch algorithm step 3 - continued from deferLoad().
 
     // 5. Wait for an implementation-defined event (e.g. the user requesting that the media element begin playback).
     // This is assumed to be whatever 'event' ended up calling this method.
     cancelDeferredLoad();
     // 6. Set the element's delaying-the-load-event flag back to true (this
     // delays the load event again, in case it hasn't been fired yet).
     setShouldDelayLoadEvent(true);
     // 7. Set the networkState to NETWORK_LOADING.
-    setNetworkState(NETWORK_LOADING);
+    setNetworkState(kNetworkLoading);
 
     startProgressEventTimer();
 
     startPlayerLoad();
 }
 
 void HTMLMediaElement::startDeferredLoad()
 {
     if (m_deferredLoadState == WaitingForTrigger) {
         executeDeferredLoad();
@@ skipping 121 matching lines @@
 }
 
 void HTMLMediaElement::waitForSourceChange()
 {
     BLINK_MEDIA_LOG << "waitForSourceChange(" << (void*)this << ")";
 
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
 
     // 6.17 - Waiting: Set the element's networkState attribute to the NETWORK_NO_SOURCE value
-    setNetworkState(NETWORK_NO_SOURCE);
+    setNetworkState(kNetworkNoSource);
 
     // 6.18 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     updateDisplayState();
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::noneSupported()
 {
     BLINK_MEDIA_LOG << "noneSupported(" << (void*)this << ")";
 
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
     m_currentSourceNode = nullptr;
 
     // 4.8.13.5
     // The dedicated media source failure steps are the following steps:
 
     // 1 - Set the error attribute to a new MediaError object whose code attribute is set to
     // MEDIA_ERR_SRC_NOT_SUPPORTED.
-    m_error = MediaError::create(MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED);
+    m_error = MediaError::create(MediaError::kMediaErrSrcNotSupported);
 
     // 2 - Forget the media element's media-resource-specific text tracks.
     forgetResourceSpecificTracks();
 
     // 3 - Set the element's networkState attribute to the NETWORK_NO_SOURCE value.
-    setNetworkState(NETWORK_NO_SOURCE);
+    setNetworkState(kNetworkNoSource);
 
     // 4 - Set the element's show poster flag to true.
     updateDisplayState();
 
     // 5 - Fire a simple event named error at the media element.
     scheduleEvent(EventTypeNames::error);
 
     // 6 - Reject pending play promises with NotSupportedError.
     scheduleRejectPlayPromises(NotSupportedError);
 
     closeMediaSource();
 
     // 7 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::mediaEngineError(MediaError* err)
 {
-    DCHECK_GE(m_readyState, HAVE_METADATA);
+    DCHECK_GE(m_readyState, kHaveMetadata);
     BLINK_MEDIA_LOG << "mediaEngineError(" << (void*)this << ", " << static_cast<int>(err->code()) << ")";
 
     // 1 - The user agent should cancel the fetching process.
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
 
     // 2 - Set the error attribute to a new MediaError object whose code attribute is
     // set to MEDIA_ERR_NETWORK/MEDIA_ERR_DECODE.
     m_error = err;
 
     // 3 - Queue a task to fire a simple event named error at the media element.
     scheduleEvent(EventTypeNames::error);
 
     // 4 - Set the element's networkState attribute to the NETWORK_IDLE value.
-    setNetworkState(NETWORK_IDLE);
+    setNetworkState(kNetworkIdle);
 
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
     m_currentSourceNode = nullptr;
 }
 
 void HTMLMediaElement::cancelPendingEventsAndCallbacks()
 {
@@ skipping 13 matching lines @@
 {
     setNetworkState(webMediaPlayer()->getNetworkState());
 }
 
 void HTMLMediaElement::mediaLoadingFailed(WebMediaPlayer::NetworkState error)
 {
     stopPeriodicTimers();
 
     // If we failed while trying to load a <source> element, the movie was never parsed, and there are more
     // <source> children, schedule the next one
-    if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {
+    if (m_readyState < kHaveMetadata && m_loadState == LoadingFromSourceElement) {
 
         // resource selection algorithm
         // Step 9.Otherwise.9 - Failed with elements: Queue a task, using the DOM manipulation task source, to fire a simple event named error at the candidate element.
         if (m_currentSourceNode)
             m_currentSourceNode->scheduleErrorEvent();
         else
             BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - error event not sent, <source> was removed";
 
         // 9.Otherwise.10 - Asynchronously await a stable state. The synchronous section consists of all the remaining steps of this algorithm until the algorithm says the synchronous section has ended.
 
         // 9.Otherwise.11 - Forget the media element's media-resource-specific tracks.
         forgetResourceSpecificTracks();
 
         if (havePotentialSourceChild()) {
             BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - scheduling next <source>";
             scheduleNextSourceChild();
         } else {
             BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - no more <source> elements, waiting";
             waitForSourceChange();
         }
 
         return;
     }
 
-    if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= HAVE_METADATA)
-        mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));
+    if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= kHaveMetadata)
+        mediaEngineError(MediaError::create(MediaError::kMediaErrNetwork));
     else if (error == WebMediaPlayer::NetworkStateDecodeError)
-        mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_DECODE));
+        mediaEngineError(MediaError::create(MediaError::kMediaErrDecode));
     else if ((error == WebMediaPlayer::NetworkStateFormatError
         || error == WebMediaPlayer::NetworkStateNetworkError)
         && m_loadState == LoadingFromSrcAttr)
         noneSupported();
 
     updateDisplayState();
     if (mediaControls())
         mediaControls()->reset();
 }
 
 void HTMLMediaElement::setNetworkState(WebMediaPlayer::NetworkState state)
 {
     BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ", " << static_cast<int>(state) << ") - current state is " << static_cast<int>(m_networkState);
 
     if (state == WebMediaPlayer::NetworkStateEmpty) {
         // Just update the cached state and leave, we can't do anything.
-        setNetworkState(NETWORK_EMPTY);
+        setNetworkState(kNetworkEmpty);
         return;
     }
 
     if (state == WebMediaPlayer::NetworkStateFormatError
         || state == WebMediaPlayer::NetworkStateNetworkError
         || state == WebMediaPlayer::NetworkStateDecodeError) {
         mediaLoadingFailed(state);
         return;
     }
 
     if (state == WebMediaPlayer::NetworkStateIdle) {
-        if (m_networkState > NETWORK_IDLE) {
+        if (m_networkState > kNetworkIdle) {
             changeNetworkStateFromLoadingToIdle();
             setShouldDelayLoadEvent(false);
         } else {
-            setNetworkState(NETWORK_IDLE);
+            setNetworkState(kNetworkIdle);
         }
     }
 
     if (state == WebMediaPlayer::NetworkStateLoading) {
-        if (m_networkState < NETWORK_LOADING || m_networkState == NETWORK_NO_SOURCE)
+        if (m_networkState < kNetworkLoading || m_networkState == kNetworkNoSource)
             startProgressEventTimer();
-        setNetworkState(NETWORK_LOADING);
+        setNetworkState(kNetworkLoading);
     }
 
     if (state == WebMediaPlayer::NetworkStateLoaded) {
-        if (m_networkState != NETWORK_IDLE)
+        if (m_networkState != kNetworkIdle)
             changeNetworkStateFromLoadingToIdle();
     }
 }
 
 void HTMLMediaElement::changeNetworkStateFromLoadingToIdle()
 {
     m_progressEventTimer.stop();
 
     // Schedule one last progress event so we guarantee that at least one is fired
     // for files that load very quickly.
     if (webMediaPlayer() && webMediaPlayer()->didLoadingProgress())
         scheduleEvent(EventTypeNames::progress);
     scheduleEvent(EventTypeNames::suspend);
-    setNetworkState(NETWORK_IDLE);
+    setNetworkState(kNetworkIdle);
 }
 
 void HTMLMediaElement::readyStateChanged()
 {
     setReadyState(static_cast<ReadyState>(webMediaPlayer()->getReadyState()));
 }
 
 void HTMLMediaElement::setReadyState(ReadyState state)
 {
     BLINK_MEDIA_LOG << "setReadyState(" << (void*)this << ", " << static_cast<int>(state) << ") - current state is " << static_cast<int>(m_readyState);
 
     // Set "wasPotentiallyPlaying" BEFORE updating m_readyState, potentiallyPlaying() uses it
     bool wasPotentiallyPlaying = potentiallyPlaying();
 
     ReadyState oldState = m_readyState;
     ReadyState newState = state;
 
     bool tracksAreReady = textTracksAreReady();
 
     if (newState == oldState && m_tracksAreReady == tracksAreReady)
         return;
 
     m_tracksAreReady = tracksAreReady;
 
     if (tracksAreReady) {
         m_readyState = newState;
     } else {
-        // If a media file has text tracks the readyState may not progress beyond HAVE_FUTURE_DATA until
+        // If a media file has text tracks the readyState may not progress beyond kHaveFutureData until
         // the text tracks are ready, regardless of the state of the media file.
-        if (newState <= HAVE_METADATA)
+        if (newState <= kHaveMetadata)
             m_readyState = newState;
         else
-            m_readyState = HAVE_CURRENT_DATA;
+            m_readyState = kHaveCurrentData;
     }
 
     if (oldState > m_readyStateMaximum)
         m_readyStateMaximum = oldState;
 
-    if (m_networkState == NETWORK_EMPTY)
+    if (m_networkState == kNetworkEmpty)
         return;
 
     if (m_seeking) {
         // 4.8.10.9, step 9 note: If the media element was potentially playing immediately before
         // it started seeking, but seeking caused its readyState attribute to change to a value
-        // lower than HAVE_FUTURE_DATA, then a waiting will be fired at the element.
-        if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA)
+        // lower than kHaveFutureData, then a waiting will be fired at the element.
+        if (wasPotentiallyPlaying && m_readyState < kHaveFutureData)
             scheduleEvent(EventTypeNames::waiting);
 
         // 4.8.10.9 steps 12-14
-        if (m_readyState >= HAVE_CURRENT_DATA)
+        if (m_readyState >= kHaveCurrentData)
             finishSeek();
     } else {
-        if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA) {
+        if (wasPotentiallyPlaying && m_readyState < kHaveFutureData) {
             // 4.8.10.8
             scheduleTimeupdateEvent(false);
             scheduleEvent(EventTypeNames::waiting);
         }
     }
 
-    if (m_readyState >= HAVE_METADATA && oldState < HAVE_METADATA) {
+    if (m_readyState >= kHaveMetadata && oldState < kHaveMetadata) {
         createPlaceholderTracksIfNecessary();
 
         selectInitialTracksIfNecessary();
 
         MediaFragmentURIParser fragmentParser(m_currentSrc);
         m_fragmentEndTime = fragmentParser.endTime();
 
         m_duration = duration();
         scheduleEvent(EventTypeNames::durationchange);
 
@@ skipping 19 matching lines @@
         }
 
         if (mediaControls())
             mediaControls()->reset();
         if (layoutObject())
             layoutObject()->updateFromElement();
     }
 
     bool shouldUpdateDisplayState = false;
 
-    if (m_readyState >= HAVE_CURRENT_DATA && oldState < HAVE_CURRENT_DATA && !m_haveFiredLoadedData) {
+    if (m_readyState >= kHaveCurrentData && oldState < kHaveCurrentData && !m_haveFiredLoadedData) {
         m_haveFiredLoadedData = true;
         shouldUpdateDisplayState = true;
         scheduleEvent(EventTypeNames::loadeddata);
         setShouldDelayLoadEvent(false);
     }
 
     bool isPotentiallyPlaying = potentiallyPlaying();
-    if (m_readyState == HAVE_FUTURE_DATA && oldState <= HAVE_CURRENT_DATA && tracksAreReady) {
+    if (m_readyState == kHaveFutureData && oldState <= kHaveCurrentData && tracksAreReady) {
         scheduleEvent(EventTypeNames::canplay);
         if (isPotentiallyPlaying)
             scheduleNotifyPlaying();
         shouldUpdateDisplayState = true;
     }
 
-    if (m_readyState == HAVE_ENOUGH_DATA && oldState < HAVE_ENOUGH_DATA && tracksAreReady) {
-        if (oldState <= HAVE_CURRENT_DATA) {
+    if (m_readyState == kHaveEnoughData && oldState < kHaveEnoughData && tracksAreReady) {
+        if (oldState <= kHaveCurrentData) {
             scheduleEvent(EventTypeNames::canplay);
             if (isPotentiallyPlaying)
                 scheduleNotifyPlaying();
         }
 
         // Check for autoplay, and record metrics about it if needed.
         if (shouldAutoplay(RecordMetricsBehavior::DoRecord)) {
             recordAutoplaySourceMetric(AutoplaySourceAttribute);
 
             // If the autoplay experiment says that it's okay to play now,
@@ skipping 27 matching lines @@
         if (mediaControls())
             mediaControls()->refreshClosedCaptionsButtonVisibility();
     }
 
     updatePlayState();
     cueTimeline().updateActiveCues(currentTime());
 }
 
 void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)
 {
-    if (m_networkState != NETWORK_LOADING)
+    if (m_networkState != kNetworkLoading)
         return;
 
     double time = WTF::currentTime();
     double timedelta = time - m_previousProgressTime;
 
     if (webMediaPlayer() && webMediaPlayer()->didLoadingProgress()) {
         scheduleEvent(EventTypeNames::progress);
         m_previousProgressTime = time;
         m_sentStalledEvent = false;
         if (layoutObject())
@@ skipping 26 matching lines @@
 }
 
 void HTMLMediaElement::seek(double time)
 {
     BLINK_MEDIA_LOG << "seek(" << (void*)this << ", " << time << ")";
 
     // 2 - If the media element's readyState is HAVE_NOTHING, abort these steps.
     // FIXME: remove m_webMediaPlayer check once we figure out how
     // m_webMediaPlayer is going out of sync with readystate.
     // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
-    if (!m_webMediaPlayer || m_readyState == HAVE_NOTHING)
+    if (!m_webMediaPlayer || m_readyState == kHaveNothing)
         return;
 
     // Ignore preload none and start load if necessary.
     setIgnorePreloadNone();
 
     // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.
     refreshCachedTime();
     // This is needed to avoid getting default playback start position from currentTime().
     double now = m_cachedTime;
 
@@ skipping 84 matching lines @@
     return webMediaPlayer() && webMediaPlayer()->hasAudio();
 }
 
 bool HTMLMediaElement::seeking() const
 {
     return m_seeking;
 }
 
 void HTMLMediaElement::refreshCachedTime() const
 {
-    if (!webMediaPlayer() || m_readyState < HAVE_METADATA)
+    if (!webMediaPlayer() || m_readyState < kHaveMetadata)
         return;
 
     m_cachedTime = webMediaPlayer()->currentTime();
 }
 
 void HTMLMediaElement::invalidateCachedTime()
 {
     BLINK_MEDIA_LOG << "invalidateCachedTime(" << (void*)this << ")";
     m_cachedTime = std::numeric_limits<double>::quiet_NaN();
 }
 
 // playback state
 double HTMLMediaElement::currentTime() const
 {
     if (m_defaultPlaybackStartPosition)
         return m_defaultPlaybackStartPosition;
 
-    if (m_readyState == HAVE_NOTHING)
+    if (m_readyState == kHaveNothing)
         return 0;
 
     if (m_seeking) {
         BLINK_MEDIA_LOG << "currentTime(" << (void*)this << ") - seeking, returning " << m_lastSeekTime;
         return m_lastSeekTime;
     }
 
     if (!std::isnan(m_cachedTime) && m_paused) {
 #if LOG_CACHED_TIME_WARNINGS
         static const double minCachedDeltaForWarning = 0.01;
         double delta = m_cachedTime - webMediaPlayer()->currentTime();
         if (delta > minCachedDeltaForWarning)
             BLINK_MEDIA_LOG << "currentTime(" << (void*)this << ") - WARNING, cached time is " << delta << "seconds off of media time when paused";
 #endif
         return m_cachedTime;
     }
 
     refreshCachedTime();
 
     return m_cachedTime;
 }
 
 void HTMLMediaElement::setCurrentTime(double time)
 {
-    // If the media element's readyState is HAVE_NOTHING, then set the default
+    // If the media element's readyState is kHaveNothing, then set the default
     // playback start position to that time.
-    if (m_readyState == HAVE_NOTHING) {
+    if (m_readyState == kHaveNothing) {
         m_defaultPlaybackStartPosition = time;
         return;
     }
 
     seek(time);
 }
 
 double HTMLMediaElement::duration() const
 {
     // FIXME: remove m_webMediaPlayer check once we figure out how
     // m_webMediaPlayer is going out of sync with readystate.
-    // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
-    if (!m_webMediaPlayer || m_readyState < HAVE_METADATA)
+    // m_webMediaPlayer is cleared but readystate is not set to kHaveNothing.
+    if (!m_webMediaPlayer || m_readyState < kHaveMetadata)
         return std::numeric_limits<double>::quiet_NaN();
 
     // FIXME: Refactor so m_duration is kept current (in both MSE and
-    // non-MSE cases) once we have transitioned from HAVE_NOTHING ->
-    // HAVE_METADATA. Currently, m_duration may be out of date for at least MSE
+    // non-MSE cases) once we have transitioned from kHaveNothing ->
+    // kHaveMetadata. Currently, m_duration may be out of date for at least MSE
     // case because MediaSource and SourceBuffer do not notify the element
     // directly upon duration changes caused by endOfStream, remove, or append
     // operations; rather the notification is triggered by the WebMediaPlayer
     // implementation observing that the underlying engine has updated duration
     // and notifying the element to consult its MediaSource for current
     // duration. See http://crbug.com/266644
 
     if (m_mediaSource)
         return m_mediaSource->duration();
 
@@ skipping 39 matching lines @@
 
 HTMLMediaElement::DirectionOfPlayback HTMLMediaElement::getDirectionOfPlayback() const
 {
     return m_playbackRate >= 0 ? Forward : Backward;
 }
 
 void HTMLMediaElement::updatePlaybackRate()
 {
     // FIXME: remove m_webMediaPlayer check once we figure out how
     // m_webMediaPlayer is going out of sync with readystate.
-    // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
+    // m_webMediaPlayer is cleared but readystate is not set to kHaveNothing.
     if (m_webMediaPlayer && potentiallyPlaying())
         webMediaPlayer()->setRate(playbackRate());
 }
 
 bool HTMLMediaElement::ended() const
 {
     // 4.8.10.8 Playing the media resource
     // The ended attribute must return true if the media element has ended
     // playback and the direction of playback is forwards, and false otherwise.
     return endedPlayback() && getDirectionOfPlayback() == Forward;
@@ skipping 144 matching lines @@
             return NotAllowedError;
         }
     } else {
         UserGestureIndicator::utilizeUserGesture();
         // We ask the helper to remove the gesture requirement for us, so that
         // it can record the reason.
         Platform::current()->recordAction(UserMetricsAction("Media_Play_WithGesture"));
         m_autoplayHelper->unlockUserGesture(GesturelessPlaybackEnabledByPlayMethod);
     }
 
-    if (m_error && m_error->code() == MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED)
+    if (m_error && m_error->code() == MediaError::kMediaErrSrcNotSupported)
         return NotSupportedError;
 
     playInternal();
 
     return nullptr;
 }
 
 void HTMLMediaElement::playInternal()
 {
     BLINK_MEDIA_LOG << "playInternal(" << (void*)this << ")";
 
     // Always return the buffering strategy to normal when not paused,
     // regardless of the cause. (In contrast with aggressive buffering which is
     // only enabled by pause(), not pauseInternal().)
     if (webMediaPlayer())
         webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal);
 
     // 4.8.10.9. Playing the media resource
-    if (m_networkState == NETWORK_EMPTY)
+    if (m_networkState == kNetworkEmpty)
         invokeResourceSelectionAlgorithm();
 
     // Generally "ended" and "looping" are exclusive. Here, the loop attribute
     // is ignored to seek back to start in case loop was set after playback
     // ended. See http://crbug.com/364442
     if (endedPlayback(LoopCondition::Ignored))
         seek(0);
 
     if (m_paused) {
         m_paused = false;
         invalidateCachedTime();
         scheduleEvent(EventTypeNames::play);
 
-        if (m_readyState <= HAVE_CURRENT_DATA)
+        if (m_readyState <= kHaveCurrentData)
             scheduleEvent(EventTypeNames::waiting);
-        else if (m_readyState >= HAVE_FUTURE_DATA)
+        else if (m_readyState >= kHaveFutureData)
             scheduleNotifyPlaying();
-    } else if (m_readyState >= HAVE_FUTURE_DATA) {
+    } else if (m_readyState >= kHaveFutureData) {
         scheduleResolvePlayPromises();
     }
 
     m_autoplaying = false;
 
     setIgnorePreloadNone();
     updatePlayState();
 }
 
 void HTMLMediaElement::pause()
 {
     BLINK_MEDIA_LOG << "pause(" << (void*)this << ")";
 
     // Only buffer aggressively on a user-initiated pause. Other types of pauses
     // (which go directly to pauseInternal()) should not cause this behavior.
     if (webMediaPlayer() && UserGestureIndicator::utilizeUserGesture())
         webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Aggressive);
 
     pauseInternal();
 }
 
 void HTMLMediaElement::pauseInternal()
 {
     BLINK_MEDIA_LOG << "pauseInternal(" << (void*)this << ")";
 
-    if (m_networkState == NETWORK_EMPTY)
+    if (m_networkState == kNetworkEmpty)
         invokeResourceSelectionAlgorithm();
 
     m_autoplayHelper->pauseMethodCalled();
 
     m_autoplaying = false;
 
     if (!m_paused) {
         m_paused = true;
         scheduleTimeupdateEvent(false);
         scheduleEvent(EventTypeNames::pause);
@@ skipping 620 matching lines @@
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
     BLINK_MEDIA_LOG << "sourceWasAdded(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
 
     // We should only consider a <source> element when there is not src attribute at all.
     if (fastHasAttribute(srcAttr))
         return;
 
     // 4.8.8 - If a source element is inserted as a child of a media element that has no src
     // attribute and whose networkState has the value NETWORK_EMPTY, the user agent must invoke
     // the media element's resource selection algorithm.
-    if (getNetworkState() == HTMLMediaElement::NETWORK_EMPTY) {
+    if (getNetworkState() == HTMLMediaElement::kNetworkEmpty) {
         invokeResourceSelectionAlgorithm();
         // Ignore current |m_nextChildNodeToConsider| and consider |source|.
         m_nextChildNodeToConsider = source;
         return;
     }
 
     if (m_currentSourceNode && source == m_currentSourceNode->nextSibling()) {
         BLINK_MEDIA_LOG << "sourceWasAdded(" << (void*)this << ") - <source> inserted immediately after current source";
         // Ignore current |m_nextChildNodeToConsider| and consider |source|.
         m_nextChildNodeToConsider = source;
         return;
     }
 
     // Consider current |m_nextChildNodeToConsider| as it is already in the middle of processing.
     if (m_nextChildNodeToConsider)
         return;
 
     if (m_loadState != WaitingForSource)
         return;
 
     // 4.8.9.5, resource selection algorithm, source elements section:
     // 21. Wait until the node after pointer is a node other than the end of the list. (This step might wait forever.)
     // 22. Asynchronously await a stable state...
     // 23. Set the element's delaying-the-load-event flag back to true (this delays the load event again, in case
     // it hasn't been fired yet).
     setShouldDelayLoadEvent(true);
 
     // 24. Set the networkState back to NETWORK_LOADING.
-    setNetworkState(NETWORK_LOADING);
+    setNetworkState(kNetworkLoading);
 
     // 25. Jump back to the find next candidate step above.
     m_nextChildNodeToConsider = source;
     scheduleNextSourceChild();
 }
 
 void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)
 {
     BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ", " << source << ")";
 
@@ skipping 18 matching lines @@
 
 void HTMLMediaElement::timeChanged()
 {
     BLINK_MEDIA_LOG << "timeChanged(" << (void*)this << ")";
 
     cueTimeline().updateActiveCues(currentTime());
 
     invalidateCachedTime();
 
     // 4.8.10.9 steps 12-14. Needed if no ReadyState change is associated with the seek.
-    if (m_seeking && m_readyState >= HAVE_CURRENT_DATA && !webMediaPlayer()->seeking())
+    if (m_seeking && m_readyState >= kHaveCurrentData && !webMediaPlayer()->seeking())
         finishSeek();
 
     // Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity,
     // it will only queue a 'timeupdate' event if we haven't already posted one at the current
     // movie time.
     scheduleTimeupdateEvent(false);
 
     double now = currentTime();
     double dur = duration();
 
@@ skipping 122 matching lines @@
     updateDisplayState();
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::sizeChanged()
 {
     BLINK_MEDIA_LOG << "sizeChanged(" << (void*)this << ")";
 
     DCHECK(hasVideo()); // "resize" makes no sense in absence of video.
-    if (m_readyState > HAVE_NOTHING && isHTMLVideoElement())
+    if (m_readyState > kHaveNothing && isHTMLVideoElement())
         scheduleEvent(EventTypeNames::resize);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 TimeRanges* HTMLMediaElement::buffered() const
 {
     if (m_mediaSource)
         return m_mediaSource->buffered();
@@ skipping 27 matching lines @@
         return m_mediaSource->seekable();
 
     return TimeRanges::create(webMediaPlayer()->seekable());
 }
 
 bool HTMLMediaElement::potentiallyPlaying() const
 {
     // "pausedToBuffer" means the media engine's rate is 0, but only because it had to stop playing
     // when it ran out of buffered data. A movie in this state is "potentially playing", modulo the
     // checks in couldPlayIfEnoughData().
-    bool pausedToBuffer = m_readyStateMaximum >= HAVE_FUTURE_DATA && m_readyState < HAVE_FUTURE_DATA;
-    return (pausedToBuffer || m_readyState >= HAVE_FUTURE_DATA) && couldPlayIfEnoughData();
+    bool pausedToBuffer = m_readyStateMaximum >= kHaveFutureData && m_readyState < kHaveFutureData;
+    return (pausedToBuffer || m_readyState >= kHaveFutureData) && couldPlayIfEnoughData();
 }
 
 bool HTMLMediaElement::couldPlayIfEnoughData() const
 {
     return !paused() && !endedPlayback() && !stoppedDueToErrors();
 }
 
 bool HTMLMediaElement::endedPlayback(LoopCondition loopCondition) const
 {
     double dur = duration();
     if (std::isnan(dur))
         return false;
 
     // 4.8.10.8 Playing the media resource
 
     // A media element is said to have ended playback when the element's
     // readyState attribute is HAVE_METADATA or greater,
-    if (m_readyState < HAVE_METADATA)
+    if (m_readyState < kHaveMetadata)
         return false;
 
     // and the current playback position is the end of the media resource and the direction
     // of playback is forwards, Either the media element does not have a loop attribute specified,
     double now = currentTime();
     if (getDirectionOfPlayback() == Forward)
         return dur > 0 && now >= dur && (loopCondition == LoopCondition::Ignored || !loop());
 
     // or the current playback position is the earliest possible position and the direction
     // of playback is backwards
     DCHECK_EQ(getDirectionOfPlayback(), Backward);
     return now <= 0;
 }
 
 bool HTMLMediaElement::stoppedDueToErrors() const
 {
-    if (m_readyState >= HAVE_METADATA && m_error) {
+    if (m_readyState >= kHaveMetadata && m_error) {
         TimeRanges* seekableRanges = seekable();
         if (!seekableRanges->contain(currentTime()))
             return true;
     }
 
     return false;
 }
 
 void HTMLMediaElement::updatePlayState()
 {
@@ skipping 93 matching lines @@
 void HTMLMediaElement::stop()
 {
     BLINK_MEDIA_LOG << "stop(" << (void*)this << ")";
 
     // Close the async event queue so that no events are enqueued.
     cancelPendingEventsAndCallbacks();
     m_asyncEventQueue->close();
 
     // Clear everything in the Media Element
     clearMediaPlayer();
-    m_readyState = HAVE_NOTHING;
-    m_readyStateMaximum = HAVE_NOTHING;
-    setNetworkState(NETWORK_EMPTY);
+    m_readyState = kHaveNothing;
+    m_readyStateMaximum = kHaveNothing;
+    setNetworkState(kNetworkEmpty);
     setShouldDelayLoadEvent(false);
     m_currentSourceNode = nullptr;
     invalidateCachedTime();
     cueTimeline().updateActiveCues(0);
     m_playing = false;
     m_paused = true;
     m_seeking = false;
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 
     stopPeriodicTimers();
 
     // Ensure that hasPendingActivity() is not preventing garbage collection, since otherwise this
     // media element will simply leak.
     DCHECK(!hasPendingActivity());
 }
 
 bool HTMLMediaElement::hasPendingActivity() const
 {
     // The delaying-the-load-event flag is set by resource selection algorithm when looking for a
-    // resource to load, before networkState has reached to NETWORK_LOADING.
+    // resource to load, before networkState has reached to kNetworkLoading.
     if (m_shouldDelayLoadEvent)
         return true;
 
-    // When networkState is NETWORK_LOADING, progress and stalled events may be fired.
-    if (m_networkState == NETWORK_LOADING)
+    // When networkState is kNetworkLoading, progress and stalled events may be fired.
+    if (m_networkState == kNetworkLoading)
         return true;
 
     // When playing or if playback may continue, timeupdate events may be fired.
     if (couldPlayIfEnoughData())
         return true;
 
     // When the seek finishes timeupdate and seeked events will be fired.
     if (m_seeking)
         return true;
 
@@ skipping 772 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink