Convert HTMLMediaElement timers to MediaElementEvent per-frame.

third_party/WebKit/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
@@ skipping 244 matching lines @@
       contentMIMEType == "application/octet-stream" ||
       contentMIMEType == "text/plain") {
     if (url.protocolIsData())
       contentMIMEType = mimeTypeFromDataURL(url.getString());
   }
 
   // If no MIME type is specified, always attempt to load.
   if (contentMIMEType.isEmpty())
     return true;
 
-  // 4.8.10.3 MIME types - In the absence of a specification to the contrary,
+  // 4.8.12.3 MIME types - In the absence of a specification to the contrary,
   // the MIME type "application/octet-stream" when used with parameters, e.g.
   // "application/octet-stream;codecs=theora", is a type that the user agent
   // knows it cannot render.
   if (contentMIMEType != "application/octet-stream" ||
       contentTypeCodecs.isEmpty()) {
     return MIMETypeRegistry::supportsMediaMIMEType(contentMIMEType,
                                                    contentTypeCodecs);
   }
 
   return false;
@@ skipping 54 matching lines @@
   DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
   String type = contentType.type().lower();
   // The codecs string is not lower-cased because MP4 values are case sensitive
   // per http://tools.ietf.org/html/rfc4281#page-7.
   String typeCodecs = contentType.parameter(codecs);
 
   if (type.isEmpty())
     return MIMETypeRegistry::IsNotSupported;
 
-  // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty
+  // 4.8.12.3 MIME types - The canPlayType(type) method must return the empty
   // string if type is a type that the user agent knows it cannot render or is
   // the type "application/octet-stream"
   if (type == "application/octet-stream")
     return MIMETypeRegistry::IsNotSupported;
 
   return MIMETypeRegistry::supportsMediaMIMEType(type, typeCodecs);
 }
 
 URLRegistry* HTMLMediaElement::s_mediaStreamRegistry = 0;
 
@@ skipping 31 matching lines @@
   for (const auto& element : elements) {
     element->updateControlsVisibility();
     element->mediaControls()->onMediaControlsEnabledChange();
   }
 }
 
 HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName,
                                    Document& document)
     : HTMLElement(tagName, document),
       SuspendableObject(&document),
-      m_loadTimer(TaskRunnerHelper::get(TaskType::Unthrottled, &document),
+      m_loadTimer(TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
                   this,
                   &HTMLMediaElement::loadTimerFired),
       m_progressEventTimer(
-          TaskRunnerHelper::get(TaskType::Unthrottled, &document),
+          TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
           this,
           &HTMLMediaElement::progressEventTimerFired),
       m_playbackProgressTimer(
-          TaskRunnerHelper::get(TaskType::Unthrottled, &document),
+          TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
           this,
           &HTMLMediaElement::playbackProgressTimerFired),
       m_audioTracksTimer(
-          TaskRunnerHelper::get(TaskType::Unthrottled, &document),
+          TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
           this,
           &HTMLMediaElement::audioTracksTimerFired),
       m_viewportFillDebouncerTimer(
-          TaskRunnerHelper::get(TaskType::Unthrottled, &document),
+          TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
           this,
           &HTMLMediaElement::viewportFillDebouncerTimerFired),
       m_checkViewportIntersectionTimer(
-          TaskRunnerHelper::get(TaskType::Unthrottled, &document),
+          TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
           this,
           &HTMLMediaElement::checkViewportIntersectionTimerFired),
       m_playedTimeRanges(),
       m_asyncEventQueue(GenericEventQueue::create(this)),
       m_playbackRate(1.0f),
       m_defaultPlaybackRate(1.0f),
       m_networkState(kNetworkEmpty),
       m_readyState(kHaveNothing),
       m_readyStateMaximum(kHaveNothing),
       m_volume(1.0f),
       m_lastSeekTime(0),
       m_previousProgressTime(std::numeric_limits<double>::max()),
       m_duration(std::numeric_limits<double>::quiet_NaN()),
       m_lastTimeUpdateEventWallTime(0),
       m_lastTimeUpdateEventMediaTime(std::numeric_limits<double>::quiet_NaN()),
       m_defaultPlaybackStartPosition(0),
       m_loadState(WaitingForSource),
       m_deferredLoadState(NotDeferred),
-      m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired),
+      m_deferredLoadTimer(
+          TaskRunnerHelper::get(TaskType::MediaElementEvent, &document),
+          this,
+          &HTMLMediaElement::deferredLoadTimerFired),
       m_webLayer(nullptr),
       m_displayMode(Unknown),
       m_officialPlaybackPosition(0),
       m_officialPlaybackPositionNeedsUpdate(true),
       m_fragmentEndTime(std::numeric_limits<double>::quiet_NaN()),
       m_pendingActionFlags(0),
       m_lockedPendingUserGesture(false),
       m_lockedPendingUserGestureIfCrossOriginExperimentEnabled(true),
       m_playing(false),
       m_shouldDelayLoadEvent(false),
@@ skipping 57 matching lines @@
   // doesn't get dispatched during the object destruction.
   // See Document::isDelayingLoadEvent().
   // Also see http://crbug.com/275223 for more details.
   clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
 }
 
 void HTMLMediaElement::didMoveToNewDocument(Document& oldDocument) {
   BLINK_MEDIA_LOG << "didMoveToNewDocument(" << (void*)this << ")";
 
   m_loadTimer.moveToNewTaskRunner(
-      TaskRunnerHelper::get(TaskType::Unthrottled, &document()));
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));
   m_progressEventTimer.moveToNewTaskRunner(
-      TaskRunnerHelper::get(TaskType::Unthrottled, &document()));
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));
   m_playbackProgressTimer.moveToNewTaskRunner(
-      TaskRunnerHelper::get(TaskType::Unthrottled, &document()));
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));
   m_audioTracksTimer.moveToNewTaskRunner(
-      TaskRunnerHelper::get(TaskType::Unthrottled, &document()));
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));
   m_viewportFillDebouncerTimer.moveToNewTaskRunner(
-      TaskRunnerHelper::get(TaskType::Unthrottled, &document()));
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));
   m_checkViewportIntersectionTimer.moveToNewTaskRunner(
-      TaskRunnerHelper::get(TaskType::Unthrottled, &document()));
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));
+  m_deferredLoadTimer.moveToNewTaskRunner(
+      TaskRunnerHelper::get(TaskType::MediaElementEvent, &document()));

[mlamouri (slow - plz ping), 2017/02/22 12:10:03]

This is a change in behaviour, right?

 
   m_autoplayUmaHelper->didMoveToNewDocument(oldDocument);
   // If any experiment is enabled, then we want to enable a user gesture by
   // default, otherwise the experiment does nothing.
   bool oldDocumentRequiresUserGesture =
       computeLockedPendingUserGesture(oldDocument);
   bool newDocumentRequiresUserGesture =
       computeLockedPendingUserGesture(document());
   if (newDocumentRequiresUserGesture && !oldDocumentRequiresUserGesture)
     m_lockedPendingUserGesture = true;
@@ skipping 202 matching lines @@
 }
 
 HTMLMediaElement::NetworkState HTMLMediaElement::getNetworkState() const {
   return m_networkState;
 }
 
 String HTMLMediaElement::canPlayType(const String& mimeType) const {
   MIMETypeRegistry::SupportsType support = supportsType(ContentType(mimeType));
   String canPlay;
 
-  // 4.8.10.3
+  // 4.8.12.3
   switch (support) {
     case MIMETypeRegistry::IsNotSupported:
       canPlay = emptyString;
       break;
     case MIMETypeRegistry::MayBeSupported:
       canPlay = "maybe";
       break;
     case MIMETypeRegistry::IsSupported:
       canPlay = "probably";
       break;
@@ skipping 467 matching lines @@
 
   if (loadIsDeferred() && effectivePreloadType() != WebMediaPlayer::PreloadNone)
     startDeferredLoad();
 }
 
 bool HTMLMediaElement::loadIsDeferred() const {
   return m_deferredLoadState != NotDeferred;
 }
 
 void HTMLMediaElement::deferLoad() {
-  // This implements the "optional" step 3 from the resource fetch algorithm.
+  // This implements the "optional" step 4 from the resource fetch algorithm
+  // "If mode is remote".
   DCHECK(!m_deferredLoadTimer.isActive());
   DCHECK_EQ(m_deferredLoadState, NotDeferred);
   // 1. Set the networkState to NETWORK_IDLE.
   // 2. Queue a task to fire a simple event named suspend at the element.
   changeNetworkStateFromLoadingToIdle();
   // 3. Queue a task to set the element's delaying-the-load-event
   // flag to false. This stops delaying the load event.
   m_deferredLoadTimer.startOneShot(0, BLINK_FROM_HERE);
   // 4. Wait for the task to be run.
   m_deferredLoadState = WaitingForStopDelayingLoadEventTask;
   // Continued in executeDeferredLoad().
 }
 
 void HTMLMediaElement::cancelDeferredLoad() {
   m_deferredLoadTimer.stop();
   m_deferredLoadState = NotDeferred;
 }
 
 void HTMLMediaElement::executeDeferredLoad() {
   DCHECK_GE(m_deferredLoadState, WaitingForTrigger);
 
-  // resource fetch algorithm step 3 - continued from deferLoad().
+  // resource fetch algorithm step 4 - continued from deferLoad().
 
   // 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.
   cancelDeferredLoad();
   // 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.
   setNetworkState(kNetworkLoading);
@@ skipping 30 matching lines @@
     return WebMediaPlayer::LoadTypeMediaSource;
 
   if (m_srcObject ||
       (!m_currentSrc.isNull() && isMediaStreamURL(m_currentSrc.getString())))
     return WebMediaPlayer::LoadTypeMediaStream;
 
   return WebMediaPlayer::LoadTypeURL;
 }
 
 bool HTMLMediaElement::textTracksAreReady() const {
-  // 4.8.10.12.1 Text track model
+  // 4.8.12.11.1 Text track model
   // ...
   // The text tracks of a media element are ready if all the text tracks whose
   // mode was not in the disabled state when the element's resource selection
   // algorithm last started now have a text track readiness state of loaded or
   // failed to load.
   for (const auto& textTrack : m_textTracksWhenResourceSelectionBegan) {
     if (textTrack->getReadinessState() == TextTrack::Loading ||
         textTrack->getReadinessState() == TextTrack::NotLoaded)
       return false;
   }
@@ skipping 113 matching lines @@
     layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::noneSupported() {
   BLINK_MEDIA_LOG << "noneSupported(" << (void*)this << ")";
 
   stopPeriodicTimers();
   m_loadState = WaitingForSource;
   m_currentSourceNode = nullptr;
 
-  // 4.8.13.5
+  // 4.8.12.5
   // The dedicated media source failure steps are the following steps:
 
   // 1 - Set the error attribute to a new MediaError object whose code attribute
   // is set to MEDIA_ERR_SRC_NOT_SUPPORTED.
   m_error = MediaError::create(MediaError::kMediaErrSrcNotSupported);
 
   // 2 - Forget the media element's media-resource-specific text tracks.
   forgetResourceSpecificTracks();
 
   // 3 - Set the element's networkState attribute to the NETWORK_NO_SOURCE
@@ skipping 196 matching lines @@
       m_readyState = kHaveCurrentData;
   }
 
   if (oldState > m_readyStateMaximum)
     m_readyStateMaximum = oldState;
 
   if (m_networkState == kNetworkEmpty)
     return;
 
   if (m_seeking) {
-    // 4.8.10.9, step 9 note: If the media element was potentially playing
+    // 4.8.12.9, step 9 note: If the media element was potentially playing
     // immediately before it started seeking, but seeking caused its readyState
     // attribute to change to a value lower than kHaveFutureData, then a waiting
     // will be fired at the element.
     if (wasPotentiallyPlaying && m_readyState < kHaveFutureData)
       scheduleEvent(EventTypeNames::waiting);
 
-    // 4.8.10.9 steps 12-14
+    // 4.8.12.9 steps 12-14
     if (m_readyState >= kHaveCurrentData)
       finishSeek();
   } else {
     if (wasPotentiallyPlaying && m_readyState < kHaveFutureData) {
       // Force an update to official playback position. Automatic updates from
       // currentPlaybackPosition() will be blocked while m_readyState remains
       // < kHaveFutureData. This blocking is desired after 'waiting' has been
       // fired, but its good to update it one final time to accurately reflect
       // media time at the moment we ran out of data to play.
       setOfficialPlaybackPosition(currentPlaybackPosition());
 
-      // 4.8.10.8
+      // 4.8.12.8
       scheduleTimeupdateEvent(false);
       scheduleEvent(EventTypeNames::waiting);
     }
   }
 
   // Once enough of the media data has been fetched to determine the duration of
   // the media resource, its dimensions, and other metadata...
   if (m_readyState >= kHaveMetadata && oldState < kHaveMetadata) {
     createPlaceholderTracksIfNecessary();
 
@@ skipping 422 matching lines @@
 
 void HTMLMediaElement::updatePlaybackRate() {
   // FIXME: remove m_webMediaPlayer check once we figure out how
   // m_webMediaPlayer is going out of sync with readystate.
   // m_webMediaPlayer is cleared but readystate is not set to kHaveNothing.
   if (m_webMediaPlayer && potentiallyPlaying())
     webMediaPlayer()->setRate(playbackRate());
 }
 
 bool HTMLMediaElement::ended() const {
-  // 4.8.10.8 Playing the media resource
+  // 4.8.12.8 Playing the media resource
   // The ended attribute must return true if the media element has ended
   // playback and the direction of playback is forwards, and false otherwise.
   return endedPlayback() && getDirectionOfPlayback() == Forward;
 }
 
 bool HTMLMediaElement::autoplay() const {
   return fastHasAttribute(autoplayAttr);
 }
 
 bool HTMLMediaElement::shouldAutoplay() {
@@ skipping 161 matching lines @@
 void HTMLMediaElement::playInternal() {
   BLINK_MEDIA_LOG << "playInternal(" << (void*)this << ")";
 
   // Always return the buffering strategy to normal when not paused,
   // regardless of the cause. (In contrast with aggressive buffering which is
   // only enabled by pause(), not pauseInternal().)
   if (webMediaPlayer())
     webMediaPlayer()->setBufferingStrategy(
         WebMediaPlayer::BufferingStrategy::Normal);
 
-  // 4.8.10.9. Playing the media resource
+  // 4.8.12.8. Playing the media resource
   if (m_networkState == kNetworkEmpty)
     invokeResourceSelectionAlgorithm();
 
   // Generally "ended" and "looping" are exclusive. Here, the loop attribute
   // is ignored to seek back to start in case loop was set after playback
   // ended. See http://crbug.com/364442
   if (endedPlayback(LoopCondition::Ignored))
     seek(0);
 
   if (m_paused) {
@@ skipping 365 matching lines @@
   return videoTrack->id();
 }
 
 void HTMLMediaElement::removeVideoTrack(WebMediaPlayer::TrackId trackId) {
   BLINK_MEDIA_LOG << "removeVideoTrack(" << (void*)this << ")";
 
   videoTracks().remove(trackId);
 }
 
 void HTMLMediaElement::addTextTrack(WebInbandTextTrack* webTrack) {
-  // 4.8.10.12.2 Sourcing in-band text tracks
+  // 4.8.12.11.2 Sourcing in-band text tracks
   // 1. Associate the relevant data with a new text track and its corresponding
   // new TextTrack object.
   InbandTextTrack* textTrack = InbandTextTrack::create(webTrack);
 
   // 2. Set the new text track's kind, label, and language based on the
   // semantics of the relevant data, as defined by the relevant specification.
   // If there is no label in that data, then the label must be set to the empty
   // string.
   // 3. Associate the text track list of cues with the rules for updating the
   // text track rendering appropriate for the format in question.
@@ skipping 90 matching lines @@
 }
 
 TextTrackList* HTMLMediaElement::textTracks() {
   if (!m_textTracks)
     m_textTracks = TextTrackList::create(this);
 
   return m_textTracks.get();
 }
 
 void HTMLMediaElement::didAddTrackElement(HTMLTrackElement* trackElement) {
-  // 4.8.10.12.3 Sourcing out-of-band text tracks
+  // 4.8.12.11.3 Sourcing out-of-band text tracks
   // When a track element's parent element changes and the new parent is a media
   // element, then the user agent must add the track element's corresponding
   // text track to the media element's list of text tracks ... [continues in
   // TextTrackList::append]
   TextTrack* textTrack = trackElement->track();
   if (!textTrack)
     return;
 
   textTracks()->append(textTrack);
 
@@ skipping 10 matching lines @@
 
   TextTrack* textTrack = trackElement->track();
   if (!textTrack)
     return;
 
   textTrack->setHasBeenConfigured(false);
 
   if (!m_textTracks)
     return;
 
-  // 4.8.10.12.3 Sourcing out-of-band text tracks
+  // 4.8.12.11.3 Sourcing out-of-band text tracks
   // When a track element's parent element changes and the old parent was a
   // media element, then the user agent must remove the track element's
   // corresponding text track from the media element's list of text tracks.
   m_textTracks->remove(textTrack);
 
   size_t index = m_textTracksWhenResourceSelectionBegan.find(textTrack);
   if (index != kNotFound)
     m_textTracksWhenResourceSelectionBegan.remove(index);
 }
 
@@ skipping 216 matching lines @@
     BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this
                     << ") - m_currentSourceNode set to 0";
   }
 }
 
 void HTMLMediaElement::timeChanged() {
   BLINK_MEDIA_LOG << "timeChanged(" << (void*)this << ")";
 
   cueTimeline().updateActiveCues(currentTime());
 
-  // 4.8.10.9 steps 12-14. Needed if no ReadyState change is associated with the
+  // 4.8.12.9 steps 12-14. Needed if no ReadyState change is associated with the
   // seek.
   if (m_seeking && m_readyState >= kHaveCurrentData &&
       !webMediaPlayer()->seeking())
     finishSeek();
 
   // Always call scheduleTimeupdateEvent when the media engine reports a time
   // discontinuity, it will only queue a 'timeupdate' event if we haven't
   // already posted one at the current movie time.
   scheduleTimeupdateEvent(false);
 
@@ skipping 230 matching lines @@
 
 bool HTMLMediaElement::couldPlayIfEnoughData() const {
   return !paused() && !endedPlayback() && !stoppedDueToErrors();
 }
 
 bool HTMLMediaElement::endedPlayback(LoopCondition loopCondition) const {
   double dur = duration();
   if (std::isnan(dur))
     return false;
 
-  // 4.8.10.8 Playing the media resource
+  // 4.8.12.8 Playing the media resource
 
   // A media element is said to have ended playback when the element's
   // readyState attribute is HAVE_METADATA or greater,
   if (m_readyState < kHaveMetadata)
     return false;
 
   // and the current playback position is the end of the media resource and the
   // direction of playback is forwards, Either the media element does not have a
   // loop attribute specified,
   double now = currentPlaybackPosition();
@@ skipping 843 matching lines @@
       kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::viewportFillDebouncerTimerFired(TimerBase*) {
   m_mostlyFillingViewport = true;
   if (m_webMediaPlayer)
     m_webMediaPlayer->becameDominantVisibleContent(m_mostlyFillingViewport);
 }
 
 }  // namespace blink