Measure usage of HTMLMediaElement preload states

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 316 matching lines @@
     , 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)
     , m_webLayer(nullptr)
-    , m_preload(MediaPlayer::Auto)
     , m_displayMode(Unknown)
     , m_cachedTime(std::numeric_limits<double>::quiet_NaN())
     , m_fragmentEndTime(std::numeric_limits<double>::quiet_NaN())
     , m_pendingActionFlags(0)
     , m_userGestureRequiredForPlay(false)
     , m_playing(false)
     , m_shouldDelayLoadEvent(false)
     , m_haveFiredLoadedData(false)
     , m_autoplaying(true)
     , m_muted(false)
@@ skipping 179 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")) {
-            m_preload = MediaPlayer::None;
-        } else if (equalIgnoringCase(value, "metadata")) {
-            m_preload = MediaPlayer::MetaData;
-        } 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 (m_player)
             setPlayerPreload();
-
     } else if (name == mediagroupAttr && RuntimeEnabledFeatures::mediaControllerEnabled()) {
         setMediaGroup(value);
     } else {
         HTMLElement::parseAttribute(name, value);
     }
 }
 
 void HTMLMediaElement::finishParsingChildren()
 {
     HTMLElement::finishParsingChildren();
@@ skipping 424 matching lines @@
                     m_mediaSource = nullptr;
                     attemptLoad = false;
                 }
             }
         }
     }
 
     if (attemptLoad && canLoadURL(url, contentType, keySystem)) {
         ASSERT(!webMediaPlayer());
 
-        if (!m_havePreparedToPlay && !autoplay() && m_preload == MediaPlayer::None) {
+        if (!m_havePreparedToPlay && !autoplay() && preloadType() == MediaPlayer::None) {
             WTF_LOG(Media, "HTMLMediaElement::loadResource(%p) : Delaying load because preload == 'none'", this);
             deferLoad();
         } else {
             startPlayerLoad();
         }
     } else {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     }
 
     // If there is no poster to display, allow the media engine to render video frames as soon as
@@ skipping 25 matching lines @@
     if (!requestURL.pass().isEmpty())
         requestURL.setPass(String());
 
     m_player->load(loadType(), requestURL, corsMode());
 }
 
 void HTMLMediaElement::setPlayerPreload()
 {
     m_player->setPreload(effectivePreloadType());
 
-    if (loadIsDeferred() && m_preload != MediaPlayer::None)
+    if (loadIsDeferred() && preloadType() != MediaPlayer::None)
         startDeferredLoad();
 }
 
 bool HTMLMediaElement::loadIsDeferred() const
 {
     return m_deferredLoadState != NotDeferred;
 }
 
 void HTMLMediaElement::deferLoad()
 {
@@ skipping 556 matching lines @@
 
 void HTMLMediaElement::seek(double time)
 {
     WTF_LOG(Media, "HTMLMediaElement::seek(%p, %f)", this, time);
 
     // 2 - If the media element's readyState is HAVE_NOTHING, abort these steps.
     if (m_readyState == HAVE_NOTHING)
         return;
 
     // If the media engine has been told to postpone loading data, let it go ahead now.
-    if (m_preload < MediaPlayer::Auto && m_readyState < HAVE_FUTURE_DATA)
+    if (preloadType() < MediaPlayer::Auto && m_readyState < HAVE_FUTURE_DATA)
         prepareToPlay();
 
     // 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;
 
     // 3 - If the element's seeking IDL attribute is true, then another instance of this algorithm is
     // already running. Abort that other instance of the algorithm without waiting for the step that
     // it is running to complete.
@@ skipping 244 matching lines @@
     return endedPlayback() && directionOfPlayback() == Forward;
 }
 
 bool HTMLMediaElement::autoplay() const
 {
     return fastHasAttribute(autoplayAttr);
 }
 
 String HTMLMediaElement::preload() const
 {
-    switch (m_preload) {
+    switch (preloadType()) {
     case MediaPlayer::None:
         return "none";
-        break;
     case MediaPlayer::MetaData:
         return "metadata";
-        break;
     case MediaPlayer::Auto:
         return "auto";
-        break;
     }
 
     ASSERT_NOT_REACHED();
     return String();
 }
 
 void HTMLMediaElement::setPreload(const AtomicString& preload)
 {
     WTF_LOG(Media, "HTMLMediaElement::setPreload(%p, %s)", this, preload.utf8().data());
     setAttribute(preloadAttr, preload);
 }
 
+MediaPlayer::Preload HTMLMediaElement::preloadType() const
+{
+    // TODO(philipj): The spec requires case-sensitive string matching:
+    // https://www.w3.org/Bugs/Public/show_bug.cgi?id=28951
+    const AtomicString& preload = getAttribute(preloadAttr);

[fs, 2015/07/15 11:07:50]

Nit: fastGetAttribute?

[philipj_slow, 2015/07/15 12:30:25]

Yes of course, thanks :)

+    if (equalIgnoringCase(preload, "none")) {
+        UseCounter::count(document(), UseCounter::HTMLMediaElementPreloadNone);
+        return MediaPlayer::None;
+    }
+    if (equalIgnoringCase(preload, "metadata")) {
+        UseCounter::count(document(), UseCounter::HTMLMediaElementPreloadMetadata);
+        return MediaPlayer::MetaData;
+    }
+    if (equalIgnoringCase(preload, "auto")) {
+        UseCounter::count(document(), UseCounter::HTMLMediaElementPreloadAuto);
+        return MediaPlayer::Auto;
+    }
+
+    // "The attribute's missing value default is user-agent defined, though the
+    // Metadata state is suggested as a compromise between reducing server load
+    // and providing an optimal user experience."
+
+    // The spec does not define an invalid value default:
+    // https://www.w3.org/Bugs/Public/show_bug.cgi?id=28950
+
+    // TODO(philipj): Try to make "metadata" the default preload state:
+    // https://crbug.com/310450
+    UseCounter::count(document(), UseCounter::HTMLMediaElementPreloadDefault);
+    return MediaPlayer::Auto;
+}
+
 MediaPlayer::Preload HTMLMediaElement::effectivePreloadType() const
 {
-    return autoplay() ? MediaPlayer::Auto : m_preload;
+    return autoplay() ? MediaPlayer::Auto : preloadType();
 }
 
 void HTMLMediaElement::play()
 {
     WTF_LOG(Media, "HTMLMediaElement::play(%p)", this);
 
     if (!UserGestureIndicator::processingUserGesture()) {
         autoplayMediaEncountered();
         if (m_userGestureRequiredForPlay) {
             String message = ExceptionMessages::failedToExecute("play", "HTMLMediaElement", "API can only be initiated by a user gesture.");
@@ skipping 1772 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!Heap::isHeapObjectAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(nullptr);
 }
 #endif
 
 }