Adding Rappor metrics for disabling cross-origin autoplay with sound experiment

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 419 matching lines @@
       m_loadState(WaitingForSource),
       m_deferredLoadState(NotDeferred),
       m_deferredLoadTimer(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),
       m_haveFiredLoadedData(false),
       m_autoplaying(true),
       m_muted(false),
       m_paused(true),
       m_seeking(false),
       m_sentStalledEvent(false),
       m_ignorePreloadNone(false),
       m_textTracksVisible(false),
@@ skipping 10 matching lines @@
       m_autoplayHelper(
           AutoplayExperimentHelper::create(m_autoplayHelperClient.get())),
       m_autoplayUmaHelper(AutoplayUmaHelper::create(this)),
       m_remotePlaybackClient(nullptr),
       m_autoplayVisibilityObserver(nullptr) {
   ThreadState::current()->registerPreFinalizer(this);
 
   BLINK_MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
 
   m_lockedPendingUserGesture = computeLockedPendingUserGesture(document);
+  m_lockedPendingUserGestureIfCrossOriginExperimentEnabled =
+      isDocumentCrossOrigin(document);
 
   LocalFrame* frame = document.frame();
   if (frame) {
     m_remotePlaybackClient =
         frame->loader().client()->createWebRemotePlaybackClient(*this);
   }
 
   setHasCustomStyleCallbacks();
   addElementToDocumentMap(this, &document);
 
@@ skipping 26 matching lines @@
 void HTMLMediaElement::didMoveToNewDocument(Document& oldDocument) {
   BLINK_MEDIA_LOG << "didMoveToNewDocument(" << (void*)this << ")";
 
   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) {
+  if (newDocumentRequiresUserGesture && !oldDocumentRequiresUserGesture)
     m_lockedPendingUserGesture = true;
-  }
 
   if (m_shouldDelayLoadEvent) {
     document().incrementLoadEventDelayCount();
     // Note: Keeping the load event delay count increment on oldDocument that
     // was added when m_shouldDelayLoadEvent was set so that destruction of
     // m_webMediaPlayer can not cause load event dispatching in oldDocument.
   } else {
     // Incrementing the load event delay count so that destruction of
     // m_webMediaPlayer can not cause load event dispatching in oldDocument.
     oldDocument.incrementLoadEventDelayCount();
   }
 
+  if (isDocumentCrossOrigin(document()) && !isDocumentCrossOrigin(oldDocument))
+    m_lockedPendingUserGestureIfCrossOriginExperimentEnabled = true;

[whywhat, 2016/11/29 21:42:04]

should you make it false in the case the new document is not cross-origin?
what about cross-origin to cross-origin move where the element was unlocked in
the old document?

could we just do m_lockedPendingUserGesture =
computeLockedPendingUserGesture(document()) and check if the document is
cross-origin?

[Zhiqiang Zhang (Slow), 2016/11/30 17:30:52]

Please see the other reply.

+
   removeElementFromDocumentMap(this, &oldDocument);
   addElementToDocumentMap(this, &document());
 
   // FIXME: This is a temporary fix to prevent this object from causing the
   // MediaPlayer to dereference LocalFrame and FrameLoader pointers from the
   // previous document. This restarts the load, as if the src attribute had been
   // set.  A proper fix would provide a mechanism to allow this object to
   // refresh the MediaPlayer's LocalFrame and FrameLoader references on document
   // changes so that playback can be resumed properly.
   m_ignorePreloadNone = false;
@@ skipping 823 matching lines @@
   // didPassCORSAccessCheck() means it was a successful CORS-enabled fetch
   // (vs. non-CORS-enabled or failed).
   // taintsCanvas() does checkAccess() on the URL plus allow data sources,
   // to ensure that it is not a URL that requires CORS (basically same
   // origin).
   return hasSingleSecurityOrigin() &&
          ((webMediaPlayer() && webMediaPlayer()->didPassCORSAccessCheck()) ||
           !origin->taintsCanvas(currentSrc()));
 }
 
+bool HTMLMediaElement::isCrossOrigin() const {
+  return isDocumentCrossOrigin(document());
+}
+
 void HTMLMediaElement::startProgressEventTimer() {
   if (m_progressEventTimer.isActive())
     return;
 
   m_previousProgressTime = WTF::currentTime();
   // 350ms is not magic, it is in the spec!
   m_progressEventTimer.startRepeating(0.350, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::waitForSourceChange() {
@@ skipping 345 matching lines @@
 
     // Check for autoplay, and record metrics about it if needed.
     if (shouldAutoplay(RecordMetricsBehavior::DoRecord)) {
       m_autoplayUmaHelper->onAutoplayInitiated(AutoplaySource::Attribute);
 
       // If the autoplay experiment says that it's okay to play now,
       // then don't require a user gesture.
       m_autoplayHelper->becameReadyToPlay();
 
       if (!isGestureNeededForPlayback()) {
+        if (isGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
+          m_autoplayUmaHelper->recordCrossOriginExperimentMetric(
+              AutoplayCrossOriginExperimentMetric::AutoplayBlocked);
+        } else {
+          m_autoplayUmaHelper->recordCrossOriginExperimentMetric(
+              AutoplayCrossOriginExperimentMetric::AutoplayAllowed);
+        }
         if (isHTMLVideoElement() && muted() &&
             RuntimeEnabledFeatures::autoplayMutedVideosEnabled()) {
           // We might end up in a situation where the previous
           // observer didn't had time to fire yet. We can avoid
           // creating a new one in this case.
           if (!m_autoplayVisibilityObserver) {
             m_autoplayVisibilityObserver = new ElementVisibilityObserver(
                 this,
                 WTF::bind(&HTMLMediaElement::onVisibilityChangedForAutoplay,
                           wrapWeakPersistent(this)));
             m_autoplayVisibilityObserver->start();
           }
         } else {
           m_paused = false;
           scheduleEvent(EventTypeNames::play);
           scheduleNotifyPlaying();
           m_autoplaying = false;
         }
+      } else {
+        m_autoplayUmaHelper->recordCrossOriginExperimentMetric(
+            AutoplayCrossOriginExperimentMetric::AutoplayBlocked);
       }
     }
 
     scheduleEvent(EventTypeNames::canplaythrough);
 
     shouldUpdateDisplayState = true;
   }
 
   if (shouldUpdateDisplayState) {
     updateDisplayState();
@@ skipping 472 matching lines @@
       if (m_autoplayHelper->isPlaybackDeferred())
         return nullptr;
 
       // If we're already playing, then this play would do nothing anyway.
       // Call playInternal to handle scheduling the promise resolution.
       if (!m_paused) {
         playInternal();
         return nullptr;
       }
 
+      m_autoplayUmaHelper->recordCrossOriginExperimentMetric(
+          AutoplayCrossOriginExperimentMetric::AutoplayBlocked);
       recordAutoplayMetric(PlayMethodFailed);
       String message = ExceptionMessages::failedToExecute(
           "play", "HTMLMediaElement",
           "API can only be initiated by a user gesture.");
       document().addConsoleMessage(ConsoleMessage::create(
           JSMessageSource, WarningMessageLevel, message));
       return NotAllowedError;
+    } else {
+      if (isGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
+        m_autoplayUmaHelper->recordCrossOriginExperimentMetric(
+            AutoplayCrossOriginExperimentMetric::AutoplayBlocked);
+      } else {
+        m_autoplayUmaHelper->recordCrossOriginExperimentMetric(

[whywhat, 2016/11/29 21:42:04]

seems like we'll record some metrics when the experiment is disabled, is that
intended?

[Zhiqiang Zhang (Slow), 2016/11/30 17:30:52]

Yes :)
Since the experiment might break many sites if it's enabled, we are recording
metrics "pretending" the experiment is enabled. This also answers why I added
"isLockedPendingUserGestureIfCrossOriginExperimentEnabled()" by side of
"isLockedPendingUserGesture()". Ditto for some other of your comments.

+            AutoplayCrossOriginExperimentMetric::AutoplayAllowed);
+      }
     }
   } else {
+    m_autoplayUmaHelper->recordCrossOriginExperimentMetric(
+        AutoplayCrossOriginExperimentMetric::PlayedWithGesture);
     UserGestureIndicator::utilizeUserGesture();
     // We ask the helper to remove the gesture requirement for us, so that
     // it can record the reason.
     m_autoplayHelper->unlockUserGesture(GesturelessPlaybackEnabledByPlayMethod);
   }
 
   if (m_error && m_error->code() == MediaError::kMediaErrSrcNotSupported)
     return NotSupportedError;
 
   playInternal();
@@ skipping 1629 matching lines @@
 
   return document.settings()->mediaPlaybackRequiresUserGesture();
 }
 
 bool HTMLMediaElement::isLockedPendingUserGesture() const {
   return m_lockedPendingUserGesture;
 }
 
 void HTMLMediaElement::unlockUserGesture() {
   m_lockedPendingUserGesture = false;
+  m_lockedPendingUserGestureIfCrossOriginExperimentEnabled = false;
 }
 
 bool HTMLMediaElement::isGestureNeededForPlayback() const {
   if (!m_lockedPendingUserGesture)
     return false;
 
   if (loadType() == WebMediaPlayer::LoadTypeMediaStream)
     return false;
 
   // We want to allow muted video to autoplay if:
   // - the flag is enabled;
   // - Data Saver is not enabled;
   // - Preload was not disabled (low end devices);
   // - Autoplay is enabled in settings;
   if (isHTMLVideoElement() && muted() &&
       RuntimeEnabledFeatures::autoplayMutedVideosEnabled() &&
       !(document().settings() && document().settings()->dataSaverEnabled()) &&
       !(document().settings() &&
         document().settings()->forcePreloadNoneForMediaElements()) &&
       isAutoplayAllowedPerSettings()) {
     return false;
   }
 
   if (m_autoplayHelper->isGestureRequirementOverridden())
     return false;
 
   return true;
 }
 
+bool HTMLMediaElement::

[whywhat, 2016/11/29 21:42:04]

how is this different from the isGestureNeededForPlayback from above?
add a check for MediaStream that you probably want and autoplay helper (which is
being removed) and it's identicall, no?

I thought you would implement it as something like

return isGestureNeededForPlayback() && isCrossOrigin() &&
isCrossOriginExperimentEnabled();

Or rather merge it to isGestureNeededForPlayback as suggested above.

[Zhiqiang Zhang (Slow), 2016/11/30 17:30:52]

Done. Added the missing checks.
The goal is to record metrics pretending that the flag is enabled even if it's
not. The best solution I can come up with is the current solution.

+    isGestureNeededForPlaybackIfCrossOriginExperimentEnabled() const {
+  if (!m_lockedPendingUserGestureIfCrossOriginExperimentEnabled)
+    return false;
+
+  if (isHTMLVideoElement() && muted() &&
+      RuntimeEnabledFeatures::autoplayMutedVideosEnabled() &&
+      !(document().settings() && document().settings()->dataSaverEnabled()) &&
+      !(document().settings() &&
+        document().settings()->forcePreloadNoneForMediaElements()) &&
+      isAutoplayAllowedPerSettings()) {
+    return false;
+  }
+
+  return true;
+}
+
 bool HTMLMediaElement::isAutoplayAllowedPerSettings() const {
   LocalFrame* frame = document().frame();
   if (!frame)
     return false;
   FrameLoaderClient* frameLoaderClient = frame->loader().client();
   return frameLoaderClient && frameLoaderClient->allowAutoplay(false);
 }
 
 void HTMLMediaElement::setNetworkState(NetworkState state) {
   if (m_networkState != state) {
@@ skipping 261 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect()
     const {
   IntRect result;
   if (LayoutObject* object = m_element->layoutObject())
     result = object->absoluteBoundingBoxRect();
   return result;
 }
 
 }  // namespace blink