Transition networkState back to NETWORK_IDLE on fetch if preload=none

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 874 matching lines @@
             }
         }
     }
 
     if (attemptLoad && canLoadURL(url, contentType, keySystem)) {
         ASSERT(!webMediaPlayer());
 
         if (!m_havePreparedToPlay && !autoplay() && m_preload == MediaPlayer::None) {
             WTF_LOG(Media, "HTMLMediaElement::loadResource : Delaying load because preload == 'none'");
             m_delayingLoadForPreloadNone = true;
+            // This implements the "optional" step 3 from the resource fetch algorithm.
+            // 1. Set the networkState to NETWORK_IDLE.
+            // 2. Queue a task to fire a simple event named suspend at the element.
+            changeNetworkStateFromLoadingToIdle();

[fs, 2014/06/09 16:12:23]

This means that we'll also fire a progress event - which could be a bad thing
(since no 'progress' will have actually taken place yet.)

[acolwell GONE FROM CHROMIUM, 2014/06/09 17:54:17]

I think we should avoid firing the progress event in this case. ISTM that the
progress event in this method should be conditional on
m_player->didLoadingProgress(). Otherwise just add an enum param that lets you
control whether the event is fired or not and update the various call sites.

[fs, 2014/06/10 12:36:24]

Added gating of 'progress' dispatch on m_player->didLoadingProgress.

+            // 3. Queue a task to set the element's delaying-the-load-event
+            // flag to false. This stops delaying the load event.
+            // 4. Wait for the task to be run.

[fs, 2014/06/09 16:12:23]

Neither queuing a nor waiting for a task here, which I presume means the load
event could end up being delivered within the current task. Don't know how much
to worry about that one. Would be nice to fix of course.

[acolwell GONE FROM CHROMIUM, 2014/06/09 17:54:17]

Why don't you just add a timer here to actually implement the queue a task
functionality?

[fs, 2014/06/10 12:36:24]

Done (PS3). But to facilitate the wait in step 4 some additional state was
needed, so I refactored the code a bit - hopefully it's not too big a change
(not a lot of "collateral damage").
Also ended up renaming from "delayed load" to "deferred load" (in part because
it easier to make the required changes) - will happily change that back to
'delayed' (or anything else, really) though.

+            setShouldDelayLoadEvent(false);
+            // Continued in startDelayedLoad().
         } else {
             startPlayerLoad();
         }
     } else {
         mediaLoadingFailed(MediaPlayer::FormatError);
     }
 
     // If there is no poster to display, allow the media engine to render video frames as soon as
     // they are available.
     updateDisplayState();
@@ skipping 31 matching lines @@
     m_player->setPreload(m_preload);
 
     if (m_delayingLoadForPreloadNone && m_preload != MediaPlayer::None)
         startDelayedLoad();
 }
 
 void HTMLMediaElement::startDelayedLoad()
 {
     ASSERT(m_delayingLoadForPreloadNone);
 
+    // resource fetch algorithm step 3 - continued from loadResource().
+
+    // 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.
     m_delayingLoadForPreloadNone = false;
+    // 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.
+    m_networkState = NETWORK_LOADING;
+
+    startProgressEventTimer();
 
     startPlayerLoad();
 }
 
 WebMediaPlayer::LoadType HTMLMediaElement::loadType() const
 {
     if (m_mediaSource)
         return WebMediaPlayer::LoadTypeMediaSource;
 
     if (isMediaStreamURL(m_currentSrc.string()))
@@ skipping 2697 matching lines @@
     visitor->trace(m_error);
     visitor->trace(m_currentSourceNode);
     visitor->trace(m_nextChildNodeToConsider);
     visitor->trace(m_textTracks);
     visitor->trace(m_textTracksWhenResourceSelectionBegan);
     WillBeHeapSupplementable<HTMLMediaElement>::trace(visitor);
     HTMLElement::trace(visitor);
 }
 
 }