Implement autoplay gesture override experiment.

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 108 matching lines @@
 
 #ifndef LOG_CACHED_TIME_WARNINGS
 // Default to not logging warnings about excessive drift in the cached media time because it adds a
 // fair amount of overhead and logging.
 #define LOG_CACHED_TIME_WARNINGS 0
 #endif
 
 // URL protocol used to signal that the media source API is being used.
 static const char mediaSourceBlobProtocol[] = "blob";
 
+// How long do we wait after a scroll event before deciding that no more
+// scroll events are going to arrive?
+static const double viewportTimerPollDelay = 0.3;
+
 using namespace HTMLNames;
 
 typedef WillBeHeapHashSet<RawPtrWillBeWeakMember<HTMLMediaElement>> WeakMediaElementSet;
 typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<Document>, WeakMediaElementSet> DocumentElementSetMap;
 static DocumentElementSetMap& documentToElementSetMap()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<DocumentElementSetMap>, map, (adoptPtrWillBeNoop(new DocumentElementSetMap())));
     return *map;
 }
 
@@ skipping 105 matching lines @@
     // 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()) {
         WebMimeRegistry::SupportsType supported = Platform::current()->mimeRegistry()->supportsMediaMIMEType(contentMIMEType, contentTypeCodecs, keySystem.lower());
         return supported > WebMimeRegistry::IsNotSupported;
     }
 
     return false;
 }
 
-// These values are used for a histogram. Do not reorder.
-enum AutoplayMetrics {
-    // Media element with autoplay seen.
-    AutoplayMediaFound = 0,
-    // Autoplay enabled and user stopped media play at any point.
-    AutoplayStopped = 1,
-    // Autoplay enabled but user bailed out on media play early.
-    AutoplayBailout = 2,
-    // Autoplay disabled but user manually started media.
-    AutoplayManualStart = 3,
-    // Autoplay was (re)enabled through a user-gesture triggered load()
-    AutoplayEnabledThroughLoad = 4,
-    // Autoplay disabled by sandbox flags.
-    AutoplayDisabledBySandbox = 5,
-    // This enum value must be last.
-    NumberOfAutoplayMetrics,
-};
-
-static void recordAutoplayMetric(AutoplayMetrics metric)
+void HTMLMediaElement::recordAutoplayMetric(AutoplayMetrics metric)
 {
     Platform::current()->histogramEnumeration("Blink.MediaElement.Autoplay", metric, NumberOfAutoplayMetrics);
 }
 
 WebMimeRegistry::SupportsType HTMLMediaElement::supportsType(const ContentType& contentType, const String& keySystem)
 {
     DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
     if (!RuntimeEnabledFeatures::mediaEnabled())
         return WebMimeRegistry::IsNotSupported;
@@ skipping 10 matching lines @@
     // 4.8.10.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 WebMimeRegistry::IsNotSupported;
 
     return Platform::current()->mimeRegistry()->supportsMediaMIMEType(type, typeCodecs, system);
 }
 
 URLRegistry* HTMLMediaElement::s_mediaStreamRegistry = 0;
 
+class HTMLMediaElement::AutoplayExperimentTouchListener : public EventListener  {
+    public:
+        AutoplayExperimentTouchListener(HTMLMediaElement* element) : EventListener(CPPEventListenerType), m_element(element) { }
+        virtual bool operator==(const EventListener& them)
+        {
+            return &them == this;
+        }
+
+        void handleEvent(ExecutionContext*, Event*) override
+        {
+            if (m_element)
+                m_element->notifyScrolled();
+        }
+
+    private:
+        HTMLMediaElement* m_element;
+};
+
 void HTMLMediaElement::setMediaStreamRegistry(URLRegistry* registry)
 {
     ASSERT(!s_mediaStreamRegistry);
     s_mediaStreamRegistry = registry;
 }
 
 bool HTMLMediaElement::isMediaStreamURL(const String& url)
 {
     return s_mediaStreamRegistry ? s_mediaStreamRegistry->contains(url) : false;
 }
@@ skipping 44 matching lines @@
     , m_haveVisibleTextTrack(false)
     , m_processingPreferenceChange(false)
     , m_remoteRoutesAvailable(false)
     , m_playingRemotely(false)
     , m_isFinalizing(false)
     , m_initialPlayWithoutUserGestures(false)
     , m_autoplayMediaCounted(false)
     , m_audioTracks(AudioTrackList::create(*this))
     , m_videoTracks(VideoTrackList::create(*this))
     , m_textTracks(nullptr)
+    , m_autoplayExperimentPlayPending(false)
+    , m_autoplayExperimentStartedByExperiment(false)
+    , m_autoplayExperimentMode(ExperimentOff)
 #if ENABLE(WEB_AUDIO)
     , m_audioSourceNode(nullptr)
 #endif
+    , m_autoplayViewportTimer(this, &HTMLMediaElement::viewportTimerFired)
+    , m_autoplayLastScrollX(std::numeric_limits<double>::quiet_NaN())
+    , m_autoplayLastScrollY(std::numeric_limits<double>::quiet_NaN())
+    , m_autoplayViewportTimerSpan(0)
 {
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
     ASSERT(RuntimeEnabledFeatures::mediaEnabled());
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
 
-    if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
-        m_userGestureRequiredForPlay = true;
+    if (document.settings()) {
+        if (document.settings()->mediaPlaybackRequiresUserGesture())
+            m_userGestureRequiredForPlay = true;
+
+        const String& autoplayMode = document.settings()->autoplayExperimentMode();
+        if (autoplayMode.contains("enabled")) {
+            // Autoplay with no gesture requirement.
+            m_autoplayExperimentMode |= ExperimentEnabled;
+        }
+        if (autoplayMode.contains("-ifviewport")) {
+            // Override gesture requirement only if the player is within the
+            // current viewport.
+            m_autoplayExperimentMode |= ExperimentIfViewport;
+        }
+        if (autoplayMode.contains("-ifmuted")) {
+            // Override gesture requirement only if the media is muted or has
+            // no audio track.
+            m_autoplayExperimentMode |= ExperimentIfMuted;
+        }
+        if (autoplayMode.contains("-ifmobile")) {
+            // Override gesture requirement only if the page is optimized
+            // for mobile.
+            m_autoplayExperimentMode |= ExperimentIfMobile;
+        }
+        if (autoplayMode.contains("-playmuted")) {
+            m_autoplayExperimentMode |= ExperimentPlayMuted;
+        }
+
+        if (m_autoplayExperimentMode != ExperimentOff) {
+            WTF_LOG(Media, "HTMLMediaElement: autoplay experiment set to '%s' (%d)",
+                autoplayMode.ascii().data(), m_autoplayExperimentMode);
+        }
+    }
 
     setHasCustomStyleCallbacks();
     addElementToDocumentMap(this, &document);
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
     WTF_LOG(Media, "HTMLMediaElement::~HTMLMediaElement(%p)", this);
+
+    autoplayExperimentClearEventListenerIfNeeded();
+
 #if !ENABLE(OILPAN)
     // HTMLMediaElement and m_asyncEventQueue always become unreachable
     // together. So HTMLMediaElement and m_asyncEventQueue are destructed in
     // the same GC. We don't need to close it explicitly in Oilpan.
     m_asyncEventQueue->close();
 
     setShouldDelayLoadEvent(false);
 
     if (m_textTracks)
         m_textTracks->clearOwner();
@@ skipping 289 matching lines @@
     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::recordMetricsIfStopping()
+{
+    // If not playing, then nothing to record.
+    if (!m_playing)
+        return;
+
+    const bool bailout = isBailout();
+
+    // Record that play was stopped.  We don't care if it was autoplay,
+    // play(), or the user manually started it.
+    recordAutoplayMetric(AnyPlaybackStopped);
+    if (bailout)
+        recordAutoplayMetric(AnyPlaybackBailout);
+
+    // If this was a gestureless play, then record that separately.
+    // These cover attr and play() gestureless starts.
+    if (m_initialPlayWithoutUserGestures) {
+        m_initialPlayWithoutUserGestures = false;
+
+        recordAutoplayMetric(AutoplayStopped);
+
+        if (bailout)
+            recordAutoplayMetric(AutoplayBailout);
+    }
+}
+
 void HTMLMediaElement::load()
 {
     WTF_LOG(Media, "HTMLMediaElement::load(%p)", this);
 
-    if (m_initialPlayWithoutUserGestures && m_playing)
-        gesturelessInitialPlayHalted();
+    recordMetricsIfStopping();
 
     if (UserGestureIndicator::processingUserGesture() && m_userGestureRequiredForPlay) {
         recordAutoplayMetric(AutoplayEnabledThroughLoad);
         m_userGestureRequiredForPlay = false;
         // While usergesture-initiated load()s technically count as autoplayed,
         // they don't feel like such to the users and hence we don't want to
         // count them for the purposes of metrics.
         m_autoplayMediaCounted = true;
     }
 
@@ skipping 835 matching lines @@
             scheduleEvent(EventTypeNames::canplay);
             if (isPotentiallyPlaying)
                 scheduleEvent(EventTypeNames::playing);
         }
 
         if (m_autoplaying && m_paused && autoplay()) {
             autoplayMediaEncountered();
 
             if (document().isSandboxed(SandboxAutomaticFeatures)) {
                 recordAutoplayMetric(AutoplayDisabledBySandbox);
-            } else if (!m_userGestureRequiredForPlay) {
-                m_paused = false;
-                invalidateCachedTime();
-                scheduleEvent(EventTypeNames::play);
-                scheduleEvent(EventTypeNames::playing);
+            } else {
+                // If the autoplay experiment says that it's okay to play now,
+                // then don't require a user gesture.
+                if (autoplayExperimentIsEligible()) {
+                    if (autoplayExperimentIsInViewportIfNeeded()) {
+                        autoplayExperimentPrepareToPlay(GesturelessPlaybackStartedByLoad);
+                        // Will play below.
+                    } else {
+                        // Wait for viewport checks to pass.
+                        autoplayExperimentInstallEventListenerIfNeeded();
+                    }
+                }
+
+                if (!m_userGestureRequiredForPlay) {
+                    m_paused = false;
+                    invalidateCachedTime();
+                    scheduleEvent(EventTypeNames::play);
+                    scheduleEvent(EventTypeNames::playing);
+                }
             }
         }
 
         scheduleEvent(EventTypeNames::canplaythrough);
 
         shouldUpdateDisplayState = true;
     }
 
     if (shouldUpdateDisplayState) {
         updateDisplayState();
@@ skipping 380 matching lines @@
 
 WebMediaPlayer::Preload HTMLMediaElement::effectivePreloadType() const
 {
     return autoplay() ? WebMediaPlayer::PreloadAuto : preloadType();
 }
 
 void HTMLMediaElement::play()
 {
     WTF_LOG(Media, "HTMLMediaElement::play(%p)", this);
 
+    // Set the pending state, even if the play isn't going to be pending.
+    // Eligibility can change if, for example, the mute status changes.
+    // Having this set is okay.
+    m_autoplayExperimentPlayPending = true;
+
     if (!UserGestureIndicator::processingUserGesture()) {
         autoplayMediaEncountered();
+
+        if (autoplayExperimentIsEligible()) {
+            // Remember that m_userGestureRequiredForPlay is required for
+            // us to be eligible for the experiment.
+            // If we are able to override the gesture requirement now, then
+            // do so.  Otherwise, install an event listener if we need one.
+            if (autoplayExperimentIsInViewportIfNeeded()) {
+                // Override the gesture and play.
+                autoplayExperimentPrepareToPlay(GesturelessPlaybackStartedByPlayMethod);
+            } else {
+                // Wait for viewport visibility.
+                autoplayExperimentInstallEventListenerIfNeeded();
+            }
+        }
+
         if (m_userGestureRequiredForPlay) {
+            recordAutoplayMetric(PlayMethodFailed);
             String message = ExceptionMessages::failedToExecute("play", "HTMLMediaElement", "API can only be initiated by a user gesture.");
             document().executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
             return;
         }
     } else if (m_userGestureRequiredForPlay) {
         if (m_autoplayMediaCounted)
             recordAutoplayMetric(AutoplayManualStart);
         m_userGestureRequiredForPlay = false;
+        autoplayExperimentClearEventListenerIfNeeded();
     }
 
     playInternal();
 }
 
 void HTMLMediaElement::playInternal()
 {
     WTF_LOG(Media, "HTMLMediaElement::playInternal(%p)", this);
 
     // 4.8.10.9. Playing the media resource
     if (m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
     // 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_mediaController)
         m_mediaController->bringElementUpToSpeed(this);
 
     if (m_paused) {
         m_paused = false;
         invalidateCachedTime();
         scheduleEvent(EventTypeNames::play);
+        recordAutoplayMetric(AnyPlaybackStarted);
 
         if (m_readyState <= HAVE_CURRENT_DATA)
             scheduleEvent(EventTypeNames::waiting);
         else if (m_readyState >= HAVE_FUTURE_DATA)
             scheduleEvent(EventTypeNames::playing);
     }
     m_autoplaying = false;
 
     updatePlayState();
     updateMediaController();
 }
 
 void HTMLMediaElement::autoplayMediaEncountered()
 {
     if (!m_autoplayMediaCounted) {
         m_autoplayMediaCounted = true;
         recordAutoplayMetric(AutoplayMediaFound);
 
         if (!m_userGestureRequiredForPlay)
             m_initialPlayWithoutUserGestures = true;
     }
 }
 
-void HTMLMediaElement::gesturelessInitialPlayHalted()
+bool HTMLMediaElement::isBailout() const
 {
-    ASSERT(m_initialPlayWithoutUserGestures);
-    m_initialPlayWithoutUserGestures = false;
-
-    recordAutoplayMetric(AutoplayStopped);
-
     // We count the user as having bailed-out on the video if they watched
     // less than one minute and less than 50% of it.
-    double playedTime = currentTime();
-    if (playedTime < 60) {
-        double progress = playedTime / duration();
-        if (progress < 0.5)
-            recordAutoplayMetric(AutoplayBailout);
-    }
+    const double playedTime = currentTime();
+    const double progress = playedTime / duration();
+    return (playedTime < 60) && (progress < 0.5);
 }
 
 void HTMLMediaElement::pause()
 {
     WTF_LOG(Media, "HTMLMediaElement::pause(%p)", this);
 
     if (m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
+    // Don't try to autoplay, if we would have.
+    m_autoplayExperimentPlayPending = false;
+    autoplayExperimentClearEventListenerIfNeeded();
+
     m_autoplaying = false;
 
     if (!m_paused) {
-        if (m_initialPlayWithoutUserGestures)
-            gesturelessInitialPlayHalted();
+        recordMetricsIfStopping();
 
         m_paused = true;
         scheduleTimeupdateEvent(false);
         scheduleEvent(EventTypeNames::pause);
     }
 
     updatePlayState();
 }
 
 void HTMLMediaElement::requestRemotePlayback()
@@ skipping 72 matching lines @@
 
 void HTMLMediaElement::setMuted(bool muted)
 {
     WTF_LOG(Media, "HTMLMediaElement::setMuted(%p, %s)", this, boolString(muted));
 
     if (m_muted == muted)
         return;
 
     m_muted = muted;
 
+    // If we are no longer eligible for the autoplay experiment, then also
+    // quit listening for events.  If we are eligible, and if we should be
+    // playing, then start playing.  In other words, start playing if
+    // we just needed 'mute' to autoplay.
+    if (!autoplayExperimentIsEligible()) {
+        autoplayExperimentClearEventListenerIfNeeded();
+    } else {
+        // Try to play.  If we can't, then install a listener.
+        if (!autoplayExperimentMaybeStartPlaying())
+            autoplayExperimentInstallEventListenerIfNeeded();
+    }
+
     updateVolume();
 
     scheduleEvent(EventTypeNames::volumechange);
 }
 
 void HTMLMediaElement::updateVolume()
 {
     if (webMediaPlayer())
         webMediaPlayer()->setVolume(effectiveMediaVolume());
 
@@ skipping 950 matching lines @@
         mediaControls()->refreshCastButtonVisibility();
 
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::stop()
 {
     WTF_LOG(Media, "HTMLMediaElement::stop(%p)", this);
 
-    if (m_playing && m_initialPlayWithoutUserGestures)
-        gesturelessInitialPlayHalted();
+    recordMetricsIfStopping();
 
     // Close the async event queue so that no events are enqueued by userCancelledLoad.
     cancelPendingEventsAndCallbacks();
     m_asyncEventQueue->close();
 
     userCancelledLoad();
 
     // Stop the playback without generating events
     m_playing = false;
     m_paused = true;
@@ skipping 656 matching lines @@
 {
     visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl)
 {
     visitor->trace(m_client);
 }
 #endif
 
+void HTMLMediaElement::autoplayExperimentInstallEventListenerIfNeeded()
+{
+    // If we don't require that the player is in the viewport, then we don't
+    // need the listener.
+    if (!(m_autoplayExperimentMode & ExperimentIfViewport))
+        return;
+
+    if (document().domWindow() && !m_autoplayExperimentTouchListener)  {
+        m_autoplayExperimentTouchListener = adoptRef(new AutoplayExperimentTouchListener(this));

[Rick Byers, 2015/08/06 15:07:49]

nit: please change the names from 'TouchListener' to 'ScrollListener' - there's
already enough confusion around the difference here ;-)

[liberato (no reviews please), 2015/08/06 15:32:27]

oops, thanks!  was tired, forgot to change the name back.

+        // Listen for events that might show a user-initiated scroll.  We
+        // don't try to catch programmatic scrolls right now.

[Rick Byers, 2015/08/06 15:07:49]

'scroll' fires for programmatic scrolls too.  Is that OK?  Maybe just update the
comment?

[liberato (no reviews please), 2015/08/06 15:32:27]

yeah, stale comment.  i really should push CLs out only in the morning.

+        document().domWindow()->addEventListener("scroll", m_autoplayExperimentTouchListener, false);
+    }
 }
+
+void HTMLMediaElement::autoplayExperimentClearEventListenerIfNeeded()
+{
+    if (m_autoplayExperimentTouchListener) {
+        LocalDOMWindow* domWindow = document().domWindow();
+        if (domWindow) {
+            domWindow->removeEventListener("scroll", m_autoplayExperimentTouchListener, false);
+        }
+        // Either way, clear our ref.
+        m_autoplayExperimentTouchListener.clear();
+    }
+}
+
+void HTMLMediaElement::notifyScrolled()
+{
+    // Reset the timer to indicate that scrolling has happened
+    // recently, and might still be ongoing.
+    m_autoplayViewportTimer.startOneShot(viewportTimerPollDelay, FROM_HERE);
+}
+
+void HTMLMediaElement::viewportTimerFired(Timer<HTMLMediaElement>*)
+{
+    // Sufficient time has passed since the last scroll that we'll
+    // treat it as the end of scroll.  Autoplay if we should.
+    autoplayExperimentMaybeStartPlaying();
+}
+
+bool HTMLMediaElement::autoplayExperimentIsInViewportIfNeeded()
+{
+    // We could check for eligibility here, but we skip it.  Some of our
+    // callers need to do it separately, and we don't want to check more
+    // than we need to.
+    // Also remember that page visibility is assumed for clank.
+
+    // If viewport visibility isn't required, then it's visible enough.
+    if (!(m_autoplayExperimentMode & ExperimentIfViewport))
+        return true;
+
+    // Check if we're in the viewport.
+    const LocalDOMWindow* domWindow = document().domWindow();
+    if (!domWindow)
+        return false;
+
+    FloatRect us(offsetLeft(), offsetTop(), clientWidth(), clientHeight());
+    FloatRect screen(domWindow->scrollX(), domWindow->scrollY(), domWindow->innerWidth(), domWindow->innerHeight());
+
+    return screen.contains(us);
+}
+
+bool HTMLMediaElement::autoplayExperimentMaybeStartPlaying()
+{
+    if (!autoplayExperimentIsEligible()
+        || !autoplayExperimentIsInViewportIfNeeded()) {
+        return false;
+    }
+
+    // Start playing!
+    autoplayExperimentPrepareToPlay(GesturelessPlaybackStartedByScroll);
+    playInternal();
+
+    return true;
+}
+
+bool HTMLMediaElement::autoplayExperimentIsEligible() const
+{
+    // If no user gesture is required, then the experiment doesn't apply.
+    // This is what prevents us from starting playback more than once.
+    // Since this flag is never set to true once it's cleared, it will block
+    // the autoplay experiment forever.
+    if (!m_userGestureRequiredForPlay)
+        return false;
+
+    if (m_autoplayExperimentMode == ExperimentOff)
+        return false;
+
+    // If nobody has requested playback, either by the autoplay attribute or
+    // a play() call, then do nothing.
+    if (!m_autoplayExperimentPlayPending && !autoplay())
+        return false;
+
+    // If the video is already playing, then do nothing.  Note that there
+    // is not a path where a user gesture is required but the video is
+    // playing.  However, we check for completeness.
+    if (!m_paused)
+        return false;
+
+    // Note that the viewport test always returns false on desktop, which is
+    // why video-autoplay-experiment.html doesn't check -ifmobile .
+    if (m_autoplayExperimentMode & ExperimentIfMobile) {
+        if (!document().viewportDescription().isLegacyViewportType())
+            return false;
+    }
+
+    if (m_autoplayExperimentMode & ExperimentIfMuted) {
+        // If media is muted, then autoplay when it comes into view.
+        return fastHasAttribute(mutedAttr) || m_muted;
+    }
+
+    // Autoplay when it comes into view (if needed), maybe muted.
+    return true;
+}
+
+void HTMLMediaElement::autoplayExperimentMuteIfNeeded()
+{
+    if (m_autoplayExperimentMode & ExperimentPlayMuted) {
+        m_muted = true;
+        updateVolume();
+    }
+}
+
+void HTMLMediaElement::autoplayExperimentPrepareToPlay(AutoplayMetrics metric)
+{
+    recordAutoplayMetric(metric);
+
+    // This also causes !autoplayExperimentIsEligible, so that we don't
+    // allow autoplay more than once.
+    m_userGestureRequiredForPlay = false;
+
+    m_autoplayExperimentStartedByExperiment = true;
+    autoplayExperimentClearEventListenerIfNeeded();
+    autoplayExperimentMuteIfNeeded();
+
+    // Record that this autoplayed without a user gesture.  This is normally
+    // set when we discover an autoplay attribute, but we include all cases
+    // where playback started without a user gesture, e.g., play().
+    m_initialPlayWithoutUserGestures = true;
+}
+
+}