Move deferred loading logic from WebMediaPlayerClientImpl to 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 67 matching lines @@
 #include "wtf/text/CString.h"
 
 #if ENABLE(WEB_AUDIO)
 #include "platform/audio/AudioSourceProvider.h"
 #include "modules/webaudio/MediaElementAudioSourceNode.h"
 #endif
 
 using namespace std;
 using blink::WebInbandTextTrack;
 using blink::WebMimeRegistry;
+using blink::WebMediaPlayer;

[philipj_slow, 2014/03/08 19:38:40]

Move up one line to keep list sorted.

[acolwell GONE FROM CHROMIUM, 2014/03/10 21:53:31]

Done.

 
 namespace WebCore {
 
 #if !LOG_DISABLED
 static String urlForLoggingMedia(const KURL& url)
 {
     static const unsigned maximumURLLengthForLogging = 128;
 
     if (url.string().length() < maximumURLLengthForLogging)
         return url.string();
@@ skipping 174 matching lines @@
     , m_pausedInternal(false)
     , m_closedCaptionsVisible(false)
     , m_completelyLoaded(false)
     , m_havePreparedToPlay(false)
     , m_tracksAreReady(true)
     , m_haveVisibleTextTrack(false)
     , m_processingPreferenceChange(false)
     , m_lastTextTrackUpdateTime(-1)
     , m_textTracks(nullptr)
     , m_ignoreTrackDisplayUpdate(0)
+    , m_delayingLoad(false)
 #if ENABLE(WEB_AUDIO)
     , m_audioSourceNode(0)
 #endif
 {
     ASSERT(RuntimeEnabledFeatures::mediaEnabled());
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement");
     ScriptWrappable::init(this);
 
     if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
@@ skipping 114 matching lines @@
         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 (!autoplay() && m_player)
-            m_player->setPreload(m_preload);
+            setPlayerPreload();
 
     } else if (name == mediagroupAttr)
         setMediaGroup(value);
     else if (name == onbeforeloadAttr)
         setAttributeEventListener(EventTypeNames::beforeload, createAttributeEventListener(this, name, value));
     else
         HTMLElement::parseAttribute(name, value);
 }
 
 void HTMLMediaElement::finishParsingChildren()
@@ skipping 405 matching lines @@
 
     // The resource fetch algorithm
     m_networkState = NETWORK_LOADING;
 
     // 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;
 
     WTF_LOG(Media, "HTMLMediaElement::loadResource - m_currentSrc -> %s", urlForLoggingMedia(m_currentSrc).utf8().data());
 
-    blink::WebMediaPlayer::LoadType loadType = blink::WebMediaPlayer::LoadTypeURL;
-
     startProgressEventTimer();
 
     // Reset display mode to force a recalculation of what to show because we are resetting the player.
     setDisplayMode(Unknown);
 
     if (!autoplay())
-        m_player->setPreload(m_preload);
+        setPlayerPreload();
 
     if (fastHasAttribute(mutedAttr))
         m_muted = true;
     updateVolume();
 
     ASSERT(!m_mediaSource);
 
     bool attemptLoad = true;
 
     if (url.protocolIs(mediaSourceBlobProtocol)) {
         if (isMediaStreamURL(url.string())) {
-            loadType = blink::WebMediaPlayer::LoadTypeMediaStream;
             m_userGestureRequiredForPlay = false;
         } else {
             m_mediaSource = HTMLMediaSource::lookup(url.string());
 
             if (m_mediaSource) {
-                loadType = blink::WebMediaPlayer::LoadTypeMediaSource;
-
                 if (!m_mediaSource->attachToElement(this)) {
                     // Forget our reference to the MediaSource, so we leave it alone
                     // while processing remainder of load failure.
                     m_mediaSource = nullptr;
                     attemptLoad = false;
                 }
             }
         }
     }
 
     if (attemptLoad && canLoadURL(url, contentType, keySystem)) {
-        m_player->load(loadType, url);
+        ASSERT(!webMediaPlayer());
+
+        if (m_preload == MediaPlayer::None) {
+            m_delayingLoad = true;

[philipj_slow, 2014/03/08 19:38:40]

http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element...

There are a bunch of things missing here, if you want to fix them. They were
missing before as well, so if you want to keep this refactoring without
observable changes that's fine too.

[acolwell GONE FROM CHROMIUM, 2014/03/10 21:53:31]

I just want to keep this CL as a simple move of existing functionality. I
figured we can do a sweep to bring things into line with the spec in later CLs.
Long-term I'd like to make the code in this file look a lot closer to the spec
text. I'm pretty sure we are aligned on that front. :)

[philipj_slow, 2014/03/12 05:21:01]

Sounds great!

+        } else {
+            m_player->load(loadType(), m_currentSrc, corsMode());
+        }
     } 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();
 
     if (renderer())
         renderer()->updateFromElement();
@@ skipping 782 matching lines @@
 {
     return m_player ? m_player->supportsSave() : false;
 }
 
 void HTMLMediaElement::prepareToPlay()
 {
     WTF_LOG(Media, "HTMLMediaElement::prepareToPlay(%p)", this);
     if (m_havePreparedToPlay)
         return;
     m_havePreparedToPlay = true;
-    m_player->prepareToPlay();
+
+    if (m_delayingLoad)
+        startDelayedLoad();
 }
 
 void HTMLMediaElement::seek(double time, ExceptionState& exceptionState)
 {
     WTF_LOG(Media, "HTMLMediaElement::seek(%f)", time);
 
     // 4.8.10.9 Seeking
 
     // 1 - If the media element's readyState is HAVE_NOTHING, then raise an InvalidStateError exception.
     if (m_readyState == HAVE_NOTHING || !m_player) {
@@ skipping 1437 matching lines @@
         m_audioSourceNode->unlock();
 #endif
 }
 
 void HTMLMediaElement::clearMediaPlayer(int flags)
 {
     forgetResourceSpecificTracks();
 
     closeMediaSource();
 
+    m_delayingLoad = false;
+
     clearMediaPlayerAndAudioSourceProviderClient();
 
     stopPeriodicTimers();
     m_loadTimer.stop();
 
     m_pendingActionFlags &= ~flags;
     m_loadState = WaitingForSource;
 
     if (m_textTracks)
         configureTextTrackDisplay(AssumeNoVisibleChange);
@@ skipping 443 matching lines @@
 
 void HTMLMediaElement::applyMediaFragmentURI()
 {
     if (m_fragmentStartTime != MediaPlayer::invalidTime()) {
         m_sentEndEvent = false;
         UseCounter::count(document(), UseCounter::HTMLMediaElementSeekToFragmentStart);
         seek(m_fragmentStartTime, IGNORE_EXCEPTION);
     }
 }
 
-MediaPlayerClient::CORSMode HTMLMediaElement::mediaPlayerCORSMode() const
+WebMediaPlayer::CORSMode HTMLMediaElement::corsMode() const
 {
     const AtomicString& crossOriginMode = fastGetAttribute(crossoriginAttr);
     if (crossOriginMode.isNull())
-        return Unspecified;
+        return WebMediaPlayer::CORSModeUnspecified;
     if (equalIgnoringCase(crossOriginMode, "use-credentials"))
-        return UseCredentials;
-    return Anonymous;
+        return WebMediaPlayer::CORSModeUseCredentials;
+    return WebMediaPlayer::CORSModeAnonymous;
 }
 
 void HTMLMediaElement::mediaPlayerSetWebLayer(blink::WebLayer* webLayer)
 {
     if (webLayer == m_webLayer)
         return;
 
     // If either of the layers is null we need to enable or disable compositing. This is done by triggering a style recalc.
     if (!m_webLayer || !webLayer)
         scheduleLayerUpdate();
@@ skipping 17 matching lines @@
 void HTMLMediaElement::mediaPlayerMediaSourceOpened(blink::WebMediaSource* webMediaSource)
 {
     m_mediaSource->setWebMediaSourceAndOpen(adoptPtr(webMediaSource));
 }
 
 bool HTMLMediaElement::isInteractiveContent() const
 {
     return fastHasAttribute(controlsAttr);
 }
 
+void HTMLMediaElement::setPlayerPreload()
+{
+    m_player->setPreload(m_preload);

[philipj_slow, 2014/03/08 19:38:40]

I had to look for a while before I understood why this can't be null. It turns
out we call createMediaPlayer in prepareForLoad() even though me might not need
it. Not in this review, but maybe it should be done at the start of the resource
fetch algorithm instead...

[acolwell GONE FROM CHROMIUM, 2014/03/10 21:53:31]

Agreed. I was surprised about this as well especially since one of the call
sites checks m_player and the other one doesn't. In general, I think we'll
probably want to revisit when m_player is actually created. Just preserving
existing behavior here for now.

+
+    if (m_delayingLoad && m_preload != MediaPlayer::None)
+        startDelayedLoad();
 }
+
+void HTMLMediaElement::startDelayedLoad()
+{
+    ASSERT(m_delayingLoad);
+
+    m_delayingLoad = false;
+
+    m_player->load(loadType(), m_currentSrc, corsMode());
+}
+
+WebMediaPlayer::LoadType HTMLMediaElement::loadType() const

[philipj_slow, 2014/03/08 19:38:40]

Maybe move these functions up together with their relatives, around load() or
loadResource()?

[acolwell GONE FROM CHROMIUM, 2014/03/10 21:53:31]

Done.

+{
+    if (m_mediaSource)
+        return WebMediaPlayer::LoadTypeMediaSource;
+
+    if (isMediaStreamURL(m_currentSrc.string()))
+        return WebMediaPlayer::LoadTypeMediaStream;
+
+    return WebMediaPlayer::LoadTypeURL;
+}
+
+}