Implement autoplay gesture override experiment.

Source/core/html/HTMLMediaElement.h

 /*
  * 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 268 matching lines @@
     void didMoveToNewDocument(Document& oldDocument) override;
     virtual KURL posterImageURL() const { return KURL(); }
 
     enum DisplayMode { Unknown, Poster, Video };
     DisplayMode displayMode() const { return m_displayMode; }
     virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
 
     void setControllerInternal(MediaController*);
 
 private:
+    // 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,
+
+        // These metrics indicate "no gesture but gesture requirement was
+        // overridden by experiment".  They do not include cases where no
+        // user gesture is required (!m_userGestureRequiredForPlay).
+        // Gestureless playback when media scrolled into view.  We don't
+        // record whether it was a javascript or attribute autoplay request.
+        GesturelessPlaybackStartedByScroll = 6,
+        // Autoplay started by experiment override during initial load.
+        GesturelessPlaybackStartedByLoad = 7,
+        // Autoplay started by experiment override in play() call.
+        GesturelessPlaybackStartedByPlayMethod = 8,
+
+        // play() failed to play due to gesture requirement.
+        PlayMethodFailed = 9,
+
+        // Some play, whether user initiated or not, started.
+        AnyPlaybackStarted = 10,
+        // Some play, whether user initiated or not, stopped.
+        AnyPlaybackStopped = 11,
+        // Some playback, whether user initiated or not, bailed out early.
+        AnyPlaybackBailout = 12,
+
+        // This enum value must be last.
+        NumberOfAutoplayMetrics,
+    };
+
     void resetMediaPlayerAndMediaSource();
 
     bool alwaysCreateUserAgentShadowRoot() const final { return true; }
     bool areAuthorShadowsAllowed() const final { return false; }
 
     bool supportsFocus() const final;
     bool isMouseFocusable() const final;
     bool layoutObjectIsNeeded(const ComputedStyle&) override;
     LayoutObject* createLayoutObject(const ComputedStyle&) override;
     InsertionNotificationRequest insertedInto(ContainerNode*) final;
@@ skipping 84 matching lines @@
     void executeDeferredLoad();
     void deferredLoadTimerFired(Timer<HTMLMediaElement>*);
 
     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
 
     void markCaptionAndSubtitleTracksAsUnconfigured();
 
     // This does not check user gesture restrictions.
     void playInternal();
 
-    void gesturelessInitialPlayHalted();
+    // If we are about to enter a stopped state, call this to record
+    // autoplay metrics.  If we were already in a stopped state, then
+    // this does nothing.
+    void recordMetricsIfStopping();
+    // Could stopping at this point be considered a bailout of playback?
+    // (as in, "The user really didn't want to play this").
+    bool isBailout() const;

[dglazkov, 2015/08/06 20:55:23]

This seems like it could be a separate CL.

     void autoplayMediaEncountered();
     void allowVideoRendering();
 
     void updateVolume();
     void updatePlayState();
     bool potentiallyPlaying() const;
     bool stoppedDueToErrors() const;
     bool couldPlayIfEnoughData() const;
 
     // Generally the presence of the loop attribute should be considered to mean playback
@@ skipping 15 matching lines @@
 
     void changeNetworkStateFromLoadingToIdle();
 
     const AtomicString& mediaGroup() const;
     void setMediaGroup(const AtomicString&);
     void updateMediaController();
     bool isBlocked() const;
     bool isBlockedOnMediaController() const;
     bool isAutoplaying() const { return m_autoplaying; }
 
+    void recordAutoplayMetric(AutoplayMetrics);
+
+    // vvvv Helpers for clank autoplay investigation vvvv

[dglazkov, 2015/08/06 20:55:23]

Please no ASCII art -___-

[liberato (no reviews please), 2015/08/07 21:53:16]

                 .-'''-.                                    
_______         '   _    \                                  
\  ___ `'.    /   /` '.   \    _..._         __.....__      
 ' |--.\  \  .   |     \  '  .'     '.   .-''         '.    
 | |    \  ' |   '      |  '.   .-.   . /     .-''"'-.  `.  
 | |     |  '\    \     / / |  '   '  |/     /________\   \ 
 | |     |  | `.   ` ..' /  |  |   |  ||                  | 
 | |     ' .'    '-...-'`   |  |   |  |\    .-------------' 
 | |___.' /'                |  |   |  | \    '-.____...---. 
/_______.'/                 |  |   |  |  `.             .'  
\_______|/                  |  |   |  |    `''-...... -'    
                            |  |   |  |                     
                            '--'   '--'                     

+
+    // Install an event listener to check for changes in visibility.  If a
+    // listener is already installed, then this does nothing.
+    void autoplayExperimentInstallEventListenerIfNeeded();

[dglazkov, 2015/08/06 20:55:23]

I would like to avoid spamming already-large class with all these extra helpers.
If they are really necessary, consider splitting them off into a helper class.

[liberato (no reviews please), 2015/08/07 21:53:16]

this change makes me happy.  PS19 has most of the autoplay experiment logic
split out into AutoplayExperimentHelper.  It's a friend class so that the newly
exposed methods can be private.  encapsulating more than that doesn't seem
worthwhile.

+
+    // Remove any event listener.  It's okay to call this if one isn't
+    // installed already.
+    void autoplayExperimentClearEventListenerIfNeeded();
+
+    // Return true if any only if this player meets (most) of the eligibility
+    // requirements for the experiment to override the need for a user
+    // gesture.  This includes everything except the visibility test.
+    bool autoplayExperimentIsEligible() const;
+
+    // Return true if and only if the player is visible.
+    bool autoplayExperimentIsInViewportIfNeeded();
+
+    // Set the mute flag on the media if we're in an experiment mode that
+    // requires it, else do nothing.
+    void autoplayExperimentMuteIfNeeded();
+
+    // Maybe override the requirement for a user gesture, and start playing
+    // autoplay media.  Returns true if only if it starts playback.
+    bool autoplayExperimentMaybeStartPlaying();
+
+    // Configure internal state to record that the autoplay experiment is
+    // going to start playback.  This doesn't actually start playback, since
+    // there are several different cases.
+    void autoplayExperimentPrepareToPlay(AutoplayMetrics);
+
+    // Begin (or start over) a periodic check for visibility.  We will poll
+    // during this check to see if the video is in the viewport.
+    void notifyScrolled();
+
+    // Process a timer for checking visibility.
+    void viewportTimerFired(Timer<HTMLMediaElement>*);
+    // ^^^^ Helpers for clank autoplay investigation ^^^^
+
     WebMediaPlayer::CORSMode corsMode() const;
 
     // Returns the "direction of playback" value as specified in the HTML5 spec.
     enum DirectionOfPlayback { Backward, Forward };
     DirectionOfPlayback directionOfPlayback() const;
 
     // Returns the "effective playback rate" value as specified in the HTML5 spec.
     double effectivePlaybackRate() const;
 
     // Creates placeholder AudioTrack and/or VideoTrack objects when WebMemediaPlayer objects
@@ skipping 108 matching lines @@
     bool m_playingRemotely : 1;
     bool m_isFinalizing : 1;
     bool m_initialPlayWithoutUserGestures : 1;
     bool m_autoplayMediaCounted : 1;
 
     PersistentWillBeMember<AudioTrackList> m_audioTracks;
     PersistentWillBeMember<VideoTrackList> m_videoTracks;
     PersistentWillBeMember<TextTrackList> m_textTracks;
     PersistentHeapVectorWillBeHeapVector<Member<TextTrack>> m_textTracksWhenResourceSelectionBegan;
 
+    // Autoplay experiment state.
+    // True if we've received a play() without a pause().
+    bool m_autoplayExperimentPlayPending : 1;
+
+    // Autoplay experiment state.
+    // True if and only if we initiated playback because of the autoplay
+    // experiment.  Once set, this is never unset.
+    bool m_autoplayExperimentStartedByExperiment : 1;
+
+    // Autoplay experiment state.
+    // Scroll listener for the autoplay experiment, to help us determine when
+    // the user has scrolled the player into the viewport.
+    class AutoplayExperimentScrollListener;
+    friend class AutoplayExperimentScrollListener;
+    RefPtrWillBeMember<EventListener> m_autoplayExperimentScrollListener;
+
+    enum AutoplayExperimentMode {
+        ExperimentOff        = 0,
+        ExperimentEnabled    = 1 << 0,
+        ExperimentIfViewport = 1 << 1,
+        ExperimentIfMuted    = 1 << 2,
+        ExperimentIfMobile   = 1 << 3,
+        ExperimentPlayMuted  = 1 << 4
+    };
+    int m_autoplayExperimentMode; // Bitwise-or of AutoplayExperimentMode
+
     OwnPtrWillBeMember<CueTimeline> m_cueTimeline;
 
 #if ENABLE(WEB_AUDIO)
     // This is a weak reference, since m_audioSourceNode holds a reference to us.
     // FIXME: Oilpan: Consider making this a strongly traced pointer with oilpan where strong cycles are not a problem.
     GC_PLUGIN_IGNORE("http://crbug.com/404577")
     RawPtrWillBeWeakMember<AudioSourceProviderClient> m_audioSourceNode;
 
     // AudioClientImpl wraps an AudioSourceProviderClient.
     // When the audio format is known, Chromium calls setFormat().
@@ skipping 38 matching lines @@
 
     private:
         WebAudioSourceProvider* m_webAudioSourceProvider;
         PersistentWillBeMember<AudioClientImpl> m_client;
         Mutex provideInputLock;
     };
 
     AudioSourceProviderImpl m_audioSourceProvider;
 #endif
 
+    Timer<HTMLMediaElement> m_autoplayViewportTimer;

[dglazkov, 2015/08/06 20:55:23]

Using timers here seems bad. Why?

[liberato (no reviews please), 2015/08/07 21:53:17]

we want to know when a scroll has (probably) ended, and that's the best idea
that i've been able to come up with.  suggestions welcome on alternate
approaches.

[ojan, 2015/08/11 02:45:21]

I think having a timer is good. The problem is what we're doing in the timer. :)

Instead of hooking at this layer, we should hook into the layout tree directly.
That will be much cheaper because it will run as part of the rendering pipeline
instead of artificially forcing the rendering pipeline to run during the timer
(which is what the offset* calls currently do). Also, then you don't need to
add/remove event listeners at all.

In term of concretes, I think what you want to do is:
1. Add a Vector<LayoutVideo*> to LayoutView (LayoutView is the root of the
Layout tree) and put any unplayed LayoutVideos in it.
2. Add a m_isVisible to LayoutVideo.
3. In FrameView::updatePostLifecycleData, loop over ever frame and update the
m_isVisible bit for each of the LayoutVideos in it. If the bit is turned on,
*then* start the timer. When the timer fires, you can read the bit to make the
appropriate decision.

In addition to being more efficient, this will fix bugs in your current patch
for when a video becomes visible due to things other than scrolling (e.g. an
animation over a transform:translate). It also means you won't do work for
display:none videos since they won't show up in the layout tree.

mpd: I added you to this review as an FYI because we'll want to incorporate this
walk into your PositionObserver walk (i.e. each video would be observed).

[liberato (no reviews please), 2015/09/01 06:54:19]

thanks for the detailed description!  the most recent CL incorporates these
changes.  the only potential weirdness is that we get called back a lot -- while
testing on desktop, this includes a callback for any mouse movement or video
frame playback.  i've tried to keep the callback light, but i'd appreciate
feedback here.  is it worth it to add another timer to debounce the callbacks a
bit?

+    double m_autoplayLastScrollX;
+    double m_autoplayLastScrollY;
+    double m_autoplayViewportTimerSpan;
+
     friend class MediaController;
     PersistentWillBeMember<MediaController> m_mediaController;
 
     friend class Internals;
     friend class TrackDisplayUpdateScope;
 
     static URLRegistry* s_mediaStreamRegistry;
 };
 
 inline bool isHTMLMediaElement(const HTMLElement& element)
 {
     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
 }
 
 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
 
 } // namespace blink
 
 #endif // HTMLMediaElement_h