Comply (more) with check-webkit-style in and around HTMLMediaElement

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 519 matching lines @@
 {
     if (name == srcAttr) {
         // Trigger a reload, as long as the 'src' attribute is present.
         if (!value.isNull()) {
             clearMediaPlayer(LoadMediaResource);
             scheduleDelayedAction(LoadMediaResource);
         }
     } else if (name == controlsAttr) {
         configureMediaControls();
     } else if (name == preloadAttr) {
-        if (equalIgnoringCase(value, "none"))
+        if (equalIgnoringCase(value, "none")) {
             m_preload = MediaPlayer::None;
-        else if (equalIgnoringCase(value, "metadata"))
+        } else if (equalIgnoringCase(value, "metadata")) {
             m_preload = MediaPlayer::MetaData;
-        else {
+        } else {
             // The spec does not define an "invalid value default" but "auto" is suggested as the
             // "missing value default", so use it for everything except "none" and "metadata"
             m_preload = MediaPlayer::Auto;
         }
 
         // The attribute must be ignored if the autoplay attribute is present
         if (!autoplay() && m_player)
             setPlayerPreload();
 
     } else if (name == mediagroupAttr && RuntimeEnabledFeatures::mediaControllerEnabled()) {
@@ skipping 137 matching lines @@
 
 String HTMLMediaElement::canPlayType(const String& mimeType, const String& keySystem) const
 {
     if (!keySystem.isNull())
         UseCounter::count(document(), UseCounter::CanPlayTypeKeySystem);
 
     WebMimeRegistry::SupportsType support = supportsType(ContentType(mimeType), keySystem);
     String canPlay;
 
     // 4.8.10.3
-    switch (support)
-    {
-        case WebMimeRegistry::IsNotSupported:
-            canPlay = emptyString();
-            break;
-        case WebMimeRegistry::MayBeSupported:
-            canPlay = "maybe";
-            break;
-        case WebMimeRegistry::IsSupported:
-            canPlay = "probably";
-            break;
+    switch (support) {
+    case WebMimeRegistry::IsNotSupported:
+        canPlay = emptyString();
+        break;
+    case WebMimeRegistry::MayBeSupported:
+        canPlay = "maybe";
+        break;
+    case WebMimeRegistry::IsSupported:
+        canPlay = "probably";
+        break;
     }
 
     WTF_LOG(Media, "HTMLMediaElement::canPlayType(%p, %s, %s) -> %s", this, mimeType.utf8().data(), keySystem.utf8().data(), canPlay.utf8().data());
 
     return canPlay;
 }
 
 void HTMLMediaElement::load()
 {
     WTF_LOG(Media, "HTMLMediaElement::load(%p)", this);
@@ skipping 493 matching lines @@
     // Explicitly cache vector sizes, as their content is constant from here.
     size_t currentCuesSize = currentCues.size();
     size_t missedCuesSize = missedCues.size();
     size_t previousCuesSize = previousCues.size();
 
     // 6 - If all of the cues in current cues have their text track cue active
     // flag set, none of the cues in other cues have their text track cue active
     // flag set, and missed cues is empty, then abort these steps.
     bool activeSetChanged = missedCuesSize;
 
-    for (size_t i = 0; !activeSetChanged && i < previousCuesSize; ++i)
+    for (size_t i = 0; !activeSetChanged && i < previousCuesSize; ++i) {
         if (!currentCues.contains(previousCues[i]) && previousCues[i].data()->isActive())
             activeSetChanged = true;
+    }
 
     for (size_t i = 0; i < currentCuesSize; ++i) {
         currentCues[i].data()->updateDisplayTree(movieTime);
 
         if (!currentCues[i].data()->isActive())
             activeSetChanged = true;
     }
 
     if (!activeSetChanged)
         return;
@@ skipping 118 matching lines @@
             m_asyncEventQueue->enqueueEvent(event.release());
         }
     }
 
     // 16 - Set the text track cue active flag of all the cues in the current
     // cues, and unset the text track cue active flag of all the cues in the
     // other cues.
     for (size_t i = 0; i < currentCuesSize; ++i)
         currentCues[i].data()->setIsActive(true);
 
-    for (size_t i = 0; i < previousCuesSize; ++i)
+    for (size_t i = 0; i < previousCuesSize; ++i) {
         if (!currentCues.contains(previousCues[i]))
             previousCues[i].data()->setIsActive(false);
+    }
 
     // Update the current active cues.
     m_currentlyActiveCues = currentCues;
 
     if (activeSetChanged)
         updateTextTrackDisplay();
 }
 
 bool HTMLMediaElement::textTracksAreReady() const
 {
@@ skipping 383 matching lines @@
     ReadyState oldState = m_readyState;
     ReadyState newState = state;
 
     bool tracksAreReady = textTracksAreReady();
 
     if (newState == oldState && m_tracksAreReady == tracksAreReady)
         return;
 
     m_tracksAreReady = tracksAreReady;
 
-    if (tracksAreReady)
+    if (tracksAreReady) {
         m_readyState = newState;
-    else {
+    } else {
         // If a media file has text tracks the readyState may not progress beyond HAVE_FUTURE_DATA until
         // the text tracks are ready, regardless of the state of the media file.
         if (newState <= HAVE_METADATA)
             m_readyState = newState;
         else
             m_readyState = HAVE_CURRENT_DATA;
     }
 
     if (oldState > m_readyStateMaximum)
         m_readyStateMaximum = oldState;
@@ skipping 1188 matching lines @@
 
         source = toHTMLSourceElement(node);
 
         // If candidate does not have a src attribute, or if its src attribute's value is the empty string ... jump down to the failed step below
         mediaURL = source->getNonEmptyURLAttribute(srcAttr);
 #if !LOG_DISABLED
         if (shouldLog)
             WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'src' is %s", this, urlForLoggingMedia(mediaURL).utf8().data());
 #endif
         if (mediaURL.isEmpty())
-            goto check_again;
+            goto checkAgain;
 
         type = source->type();
         // FIXME(82965): Add support for keySystem in <source> and set system from source.
         if (type.isEmpty() && mediaURL.protocolIsData())
             type = mimeTypeFromDataURL(mediaURL);
         if (!type.isEmpty() || !system.isEmpty()) {
 #if !LOG_DISABLED
             if (shouldLog)
                 WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'type' is '%s' - key system is '%s'", this, type.utf8().data(), system.utf8().data());
 #endif
             if (!supportsType(ContentType(type), system))
-                goto check_again;
+                goto checkAgain;
         }
 
         // Is it safe to load this url?
         if (!isSafeToLoadURL(mediaURL, actionIfInvalid))
-            goto check_again;
+            goto checkAgain;
 
         // Making it this far means the <source> looks reasonable.
         canUseSourceElement = true;
 
-check_again:
+checkAgain:
         if (!canUseSourceElement && actionIfInvalid == Complain && source)
             source->scheduleErrorEvent();
     }
 
     if (canUseSourceElement) {
         if (contentType)
             *contentType = ContentType(type);
         if (keySystem)
             *keySystem = system;
         m_currentSourceNode = source;
@@ skipping 123 matching lines @@
             }
             // Queue a task to fire a simple event named ended at the media element.
             if (!m_sentEndEvent) {
                 m_sentEndEvent = true;
                 scheduleEvent(EventTypeNames::ended);
             }
             // If the media element has a current media controller, then report the controller state
             // for the media element's current media controller.
             updateMediaController();
         }
+    } else {
+        m_sentEndEvent = false;
     }
-    else
-        m_sentEndEvent = false;
 
     updatePlayState();
 }
 
 void HTMLMediaElement::mediaPlayerDurationChanged()
 {
     WTF_LOG(Media, "HTMLMediaElement::mediaPlayerDurationChanged(%p)", this);
     // FIXME: Change MediaPlayerClient & WebMediaPlayer to convey
     // the currentTime when the duration change occured. The current
     // WebMediaPlayer implementations always clamp currentTime() to
@@ skipping 264 matching lines @@
 
     closeMediaSource();
 
     // 4 - If the media element's readyState attribute has a value equal to HAVE_NOTHING, set the
     // element's networkState attribute to the NETWORK_EMPTY value and queue a task to fire a
     // simple event named emptied at the element. Otherwise, set the element's networkState
     // attribute to the NETWORK_IDLE value.
     if (m_readyState == HAVE_NOTHING) {
         m_networkState = NETWORK_EMPTY;
         scheduleEvent(EventTypeNames::emptied);
+    } else {
+        m_networkState = NETWORK_IDLE;
     }
-    else
-        m_networkState = NETWORK_IDLE;
 
     // 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;
 
     // Reset m_readyState since m_player is gone.
     m_readyState = HAVE_NOTHING;
     invalidateCachedTime();
@@ skipping 581 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!visitor->isAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(0);
 }
 #endif
 
 }