Rename Blink constants generated from IDL files.

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

 /*
  * Copyright (C) 2011 Google 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 155 matching lines @@
     // 5. Top: Await a stable state. The synchronous section consists of the following steps. (The steps in the
     // synchronous section are marked with [X])
     // FIXME: We use a timer to approximate a "stable state" - i.e. this is not 100% per spec.
 }
 
 void HTMLTrackElement::loadTimerFired(TimerBase*)
 {
     DVLOG(TRACK_LOG_LEVEL) << "loadTimerFired";
 
     // 6. [X] Set the text track readiness state to loading.
-    setReadyState(LOADING);
+    setReadyState(kLoading);
 
     // 7. [X] Let URL be the track URL of the track element.
     KURL url = getNonEmptyURLAttribute(srcAttr);
 
     // 8. [X] If the track element's parent is a media element then let CORS mode be the state of the parent media
     // element's crossorigin content attribute. Otherwise, let CORS mode be No CORS.
     const AtomicString& corsMode = mediaElementCrossOriginAttribute();
 
     // 9. End the synchronous section, continuing the remaining steps in parallel.
 
@@ skipping 63 matching lines @@
     // (Note: We don't "queue a task" here because this method will only be called from a timer - m_loadTimer or
     // TextTrackLoader::m_cueLoadTimer - which should be a reasonable, and hopefully non-observable, approximation of
     // the spec text. I.e we could consider this to be run from the "networking task source".)
     //
     // If the fetching algorithm does not fail, but the type of the resource is not a supported text track format, or
     // the file was not successfully processed (e.g. the format in question is an XML format and the file contained a
     // well-formedness error that the XML specification requires be detected and reported to the application), then the
     // task that is queued by the networking task source in which the aforementioned problem is found must change the
     // text track readiness state to failed to load and fire a simple event named error at the track element.
     if (status == Failure) {
-        setReadyState(TRACK_ERROR);
+        setReadyState(kError);
         dispatchEvent(Event::create(EventTypeNames::error));
         return;
     }
 
     // If the fetching algorithm does not fail, and the file was successfully processed, then the final task that is
     // queued by the networking task source, after it has finished parsing the data, must change the text track
     // readiness state to loaded, and fire a simple event named load at the track element.
-    setReadyState(LOADED);
+    setReadyState(kLoaded);
     dispatchEvent(Event::create(EventTypeNames::load));
 }
 
 void HTMLTrackElement::newCuesAvailable(TextTrackLoader* loader)
 {
     DCHECK_EQ(m_loader, loader);
     DCHECK(m_track);
 
     HeapVector<Member<TextTrackCue>> newCues;
     m_loader->getNewCues(newCues);
@@ skipping 13 matching lines @@
 }
 
 void HTMLTrackElement::cueLoadingCompleted(TextTrackLoader* loader, bool loadingFailed)
 {
     DCHECK_EQ(m_loader, loader);
 
     didCompleteLoad(loadingFailed ? Failure : Success);
 }
 
 // NOTE: The values in the TextTrack::ReadinessState enum must stay in sync with those in HTMLTrackElement::ReadyState.
-static_assert(HTMLTrackElement::NONE == static_cast<HTMLTrackElement::ReadyState>(TextTrack::NotLoaded), "HTMLTrackElement::NONE should be in sync with TextTrack::NotLoaded");
-static_assert(HTMLTrackElement::LOADING == static_cast<HTMLTrackElement::ReadyState>(TextTrack::Loading), "HTMLTrackElement::LOADING should be in sync with TextTrack::Loading");
-static_assert(HTMLTrackElement::LOADED == static_cast<HTMLTrackElement::ReadyState>(TextTrack::Loaded), "HTMLTrackElement::LOADED should be in sync with TextTrack::Loaded");
-static_assert(HTMLTrackElement::TRACK_ERROR == static_cast<HTMLTrackElement::ReadyState>(TextTrack::FailedToLoad), "HTMLTrackElement::TRACK_ERROR should be in sync with TextTrack::FailedToLoad");
+static_assert(HTMLTrackElement::kNone == static_cast<HTMLTrackElement::ReadyState>(TextTrack::NotLoaded), "HTMLTrackElement::kNone should be in sync with TextTrack::NotLoaded");
+static_assert(HTMLTrackElement::kLoading == static_cast<HTMLTrackElement::ReadyState>(TextTrack::Loading), "HTMLTrackElement::kLoading should be in sync with TextTrack::Loading");
+static_assert(HTMLTrackElement::kLoaded == static_cast<HTMLTrackElement::ReadyState>(TextTrack::Loaded), "HTMLTrackElement::kLoaded should be in sync with TextTrack::Loaded");
+static_assert(HTMLTrackElement::kError == static_cast<HTMLTrackElement::ReadyState>(TextTrack::FailedToLoad), "HTMLTrackElement::kError should be in sync with TextTrack::FailedToLoad");
 
 void HTMLTrackElement::setReadyState(ReadyState state)
 {
     ensureTrack()->setReadinessState(static_cast<TextTrack::ReadinessState>(state));
     if (HTMLMediaElement* parent = mediaElement())
         return parent->textTrackReadyStateChanged(m_track.get());
 }
 
 HTMLTrackElement::ReadyState HTMLTrackElement::getReadyState()
 {
@@ skipping 17 matching lines @@
 }
 
 DEFINE_TRACE(HTMLTrackElement)
 {
     visitor->trace(m_track);
     visitor->trace(m_loader);
     HTMLElement::trace(visitor);
 }
 
 } // namespace blink