[Blink>Media] Moving autoplay logic to AutoplayPolicy

third_party/WebKit/Source/core/html/media/AutoplayPolicy.cpp

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/html/media/AutoplayPolicy.h"
+
+#include "core/dom/Document.h"
+#include "core/dom/ElementVisibilityObserver.h"
+#include "core/frame/ContentSettingsClient.h"
+#include "core/frame/LocalFrame.h"
+#include "core/frame/Settings.h"
+#include "core/html/HTMLMediaElement.h"
+#include "core/html/media/AutoplayUmaHelper.h"
+#include "platform/RuntimeEnabledFeatures.h"
+#include "platform/UserGestureIndicator.h"
+#include "public/platform/WebMediaPlayer.h"
+
+namespace blink {
+
+namespace {
+
+bool IsDocumentCrossOrigin(Document& document) {
+  const LocalFrame* frame = document.GetFrame();
+  return frame && frame->IsCrossOriginSubframe();
+}
+
+bool IsDocumentWhitelisted(Document& document) {

[mlamouri (slow - plz ping), 2017/04/19 14:09:55]

nit: add comment explaining what this is doing?

[Zhiqiang Zhang (Slow), 2017/04/20 10:30:45]

Done.

+  DCHECK(document.GetSettings());
+
+  const String& whitelist_scope =
+      document.GetSettings()->GetMediaPlaybackGestureWhitelistScope();
+  if (whitelist_scope.IsNull() || whitelist_scope.IsEmpty())
+    return false;
+
+  return document.Url().GetString().StartsWith(whitelist_scope);
+}
+
+// Return true if and only if the document settings specifies media playback
+// requires user gesture.
+bool ComputeLockedPendingUserGesture(Document& document) {
+  if (!document.GetSettings())
+    return false;
+
+  if (IsDocumentWhitelisted(document)) {
+    return false;
+  }
+
+  if (document.GetSettings()
+          ->GetCrossOriginMediaPlaybackRequiresUserGesture() &&
+      IsDocumentCrossOrigin(document)) {
+    return true;
+  }
+
+  return document.GetSettings()->GetMediaPlaybackRequiresUserGesture();
+}
+
+}  // anonymous namespace
+
+AutoplayPolicy::AutoplayPolicy(HTMLMediaElement* element)
+    : locked_pending_user_gesture_(false),
+      locked_pending_user_gesture_if_cross_origin_experiment_enabled_(true),
+      element_(element),
+      autoplay_visibility_observer_(nullptr),
+      autoplay_uma_helper_(AutoplayUmaHelper::Create(element)) {
+  locked_pending_user_gesture_ =
+      ComputeLockedPendingUserGesture(element->GetDocument());
+  locked_pending_user_gesture_if_cross_origin_experiment_enabled_ =
+      IsDocumentCrossOrigin(element->GetDocument());
+}
+
+void AutoplayPolicy::VideoWillBeDrawnToCanvas() const {
+  autoplay_uma_helper_->VideoWillBeDrawnToCanvas();
+}
+
+void AutoplayPolicy::DidMoveToNewDocument(Document& old_document) {
+  // If any experiment is enabled, then we want to enable a user gesture by
+  // default, otherwise the experiment does nothing.
+  bool old_document_requires_user_gesture =
+      ComputeLockedPendingUserGesture(old_document);
+  bool new_document_requires_user_gesture =
+      ComputeLockedPendingUserGesture(element_->GetDocument());
+  if (new_document_requires_user_gesture && !old_document_requires_user_gesture)
+    locked_pending_user_gesture_ = true;
+
+  if (IsDocumentCrossOrigin(element_->GetDocument()) &&
+      !IsDocumentCrossOrigin(old_document))
+    locked_pending_user_gesture_if_cross_origin_experiment_enabled_ = true;
+
+  autoplay_uma_helper_->DidMoveToNewDocument(old_document);
+}
+
+bool AutoplayPolicy::IsEligibleForAutoplayMuted() const {
+  return element_->IsHTMLVideoElement() && element_->muted() &&
+         RuntimeEnabledFeatures::autoplayMutedVideosEnabled();
+}
+
+void AutoplayPolicy::StartAutoplayMutedWhenVisible() {
+  // 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 (autoplay_visibility_observer_)
+    return;
+
+  autoplay_visibility_observer_ = new ElementVisibilityObserver(
+      element_, WTF::Bind(&AutoplayPolicy::OnVisibilityChangedForAutoplay,
+                          WrapWeakPersistent(this)));
+  autoplay_visibility_observer_->Start();
+}
+
+void AutoplayPolicy::StopAutoplayMutedWhenVisible() {
+  if (!autoplay_visibility_observer_)
+    return;
+
+  autoplay_visibility_observer_->Stop();
+  autoplay_visibility_observer_ = nullptr;
+}
+
+bool AutoplayPolicy::RequestAutoplayUnmute() {
+  if (!element_->IsHTMLVideoElement() ||
+      !RuntimeEnabledFeatures::autoplayMutedVideosEnabled()) {
+    return false;
+  }
+  bool result =
+      !element_->paused() && element_->muted() && IsLockedPendingUserGesture();
+  if (result) {
+    autoplay_uma_helper_->RecordAutoplayUnmuteStatus(
+        AutoplayUnmuteActionStatus::kFailure);
+  } else {
+    autoplay_uma_helper_->RecordAutoplayUnmuteStatus(
+        AutoplayUnmuteActionStatus::kSuccess);
+  }
+  return result;
+}
+
+bool AutoplayPolicy::RequestAutoplayByAttribute() {
+  if (ShouldAutoplay()) {

[mlamouri (slow - plz ping), 2017/04/19 14:09:55]

maybe an early return would be better? :)

[Zhiqiang Zhang (Slow), 2017/04/20 10:30:45]

Done. Also moved the code a bit to make the logic simpler.

+    autoplay_uma_helper_->OnAutoplayInitiated(AutoplaySource::kAttribute);
+
+    if (!IsGestureNeededForPlayback()) {
+      if (IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
+        autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+            CrossOriginAutoplayResult::kAutoplayBlocked);
+      } else {
+        autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+            CrossOriginAutoplayResult::kAutoplayAllowed);
+      }
+      if (IsEligibleForAutoplayMuted())
+        StartAutoplayMutedWhenVisible();
+      else
+        return true;
+    } else {
+      autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+          CrossOriginAutoplayResult::kAutoplayBlocked);
+    }
+  }
+  return false;
+}
+
+Nullable<ExceptionCode> AutoplayPolicy::RequestPlay() {
+  if (!UserGestureIndicator::ProcessingUserGesture()) {
+    autoplay_uma_helper_->OnAutoplayInitiated(AutoplaySource::kMethod);
+    if (IsGestureNeededForPlayback()) {
+      autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+          CrossOriginAutoplayResult::kAutoplayBlocked);
+      return kNotAllowedError;
+    }
+
+    if (IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled()) {
+      autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+          CrossOriginAutoplayResult::kAutoplayBlocked);
+    } else {
+      autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+          CrossOriginAutoplayResult::kAutoplayAllowed);
+    }
+  } else {
+    autoplay_uma_helper_->RecordCrossOriginAutoplayResult(
+        CrossOriginAutoplayResult::kPlayedWithGesture);
+    UserGestureIndicator::UtilizeUserGesture();
+    UnlockUserGesture();
+  }
+  return nullptr;

[mlamouri (slow - plz ping), 2017/04/19 14:09:55]

empty line above?

[Zhiqiang Zhang (Slow), 2017/04/20 10:30:45]

Done.

+}
+
+bool AutoplayPolicy::IsAutoplayingMuted() {
+  if (!element_->IsHTMLVideoElement() ||
+      !RuntimeEnabledFeatures::autoplayMutedVideosEnabled()) {
+    return false;
+  }
+
+  return !element_->paused() && element_->muted() &&
+         IsLockedPendingUserGesture();
+}
+
+bool AutoplayPolicy::IsLockedPendingUserGesture() const {
+  return locked_pending_user_gesture_;

[mlamouri (slow - plz ping), 2017/04/19 14:09:55]

stupid question: I know it's a copy-paste from the previous code but should this
consider `locked_pending_user_gesture_if_cross_origin_experiment_enabled_`?
maybe not the right CL to do this change but wdyt?

[Zhiqiang Zhang (Slow), 2017/04/20 10:30:45]

We shouldn't consider
locked_pending_user_gesture_if_cross_origin_experiment_enabled_ here.

The history is that we need to pretend the cross-origin experiment is ON to
record the UMA. Therefore we are having a separate set of flags/methods for the
experiment. The logic should be the same with the original user gesture lock,
but it will only take effect when the experiment is really ON.

You can check ComputeLockedPendingUserGesture()

+}
+
+void AutoplayPolicy::TryUnlockingUserGesture() {
+  if (IsLockedPendingUserGesture() &&
+      UserGestureIndicator::UtilizeUserGesture()) {
+    UnlockUserGesture();
+  }
+}
+
+void AutoplayPolicy::UnlockUserGesture() {
+  locked_pending_user_gesture_ = false;
+  locked_pending_user_gesture_if_cross_origin_experiment_enabled_ = false;
+}
+
+bool AutoplayPolicy::IsGestureNeededForPlayback() const {
+  if (!locked_pending_user_gesture_)
+    return false;
+
+  return IsGestureNeededForPlaybackIfPendingUserGestureIsLocked();
+}
+
+bool AutoplayPolicy::IsGestureNeededForPlaybackIfPendingUserGestureIsLocked()
+    const {
+  if (element_->GetLoadType() == WebMediaPlayer::kLoadTypeMediaStream)
+    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 (element_->IsHTMLVideoElement() && element_->muted() &&
+      RuntimeEnabledFeatures::autoplayMutedVideosEnabled() &&
+      !(element_->GetDocument().GetSettings() &&
+        element_->GetDocument().GetSettings()->GetDataSaverEnabled()) &&
+      !(element_->GetDocument().GetSettings() &&
+        element_->GetDocument()
+            .GetSettings()
+            ->GetForcePreloadNoneForMediaElements()) &&
+      IsAutoplayAllowedPerSettings()) {
+    return false;
+  }
+
+  return true;
+}
+
+void AutoplayPolicy::OnVisibilityChangedForAutoplay(bool is_visible) {
+  if (!is_visible) {
+    if (element_->can_autoplay_ && element_->Autoplay()) {
+      element_->PauseInternal();
+      element_->can_autoplay_ = true;
+    }
+    return;
+  }
+
+  if (ShouldAutoplay()) {
+    element_->paused_ = false;
+    element_->ScheduleEvent(EventTypeNames::play);
+    element_->ScheduleNotifyPlaying();
+
+    element_->UpdatePlayState();
+  }
+}
+
+bool AutoplayPolicy::IsGestureNeededForPlaybackIfCrossOriginExperimentEnabled()
+    const {
+  if (!locked_pending_user_gesture_if_cross_origin_experiment_enabled_)
+    return false;
+
+  return IsGestureNeededForPlaybackIfPendingUserGestureIsLocked();
+}
+
+bool AutoplayPolicy::IsAutoplayAllowedPerSettings() const {
+  LocalFrame* frame = element_->GetDocument().GetFrame();
+  if (!frame)
+    return false;
+  return frame->GetContentSettingsClient()->AllowAutoplay(true);
+}
+
+bool AutoplayPolicy::ShouldAutoplay() {
+  if (element_->GetDocument().IsSandboxed(kSandboxAutomaticFeatures))
+    return false;
+  return element_->can_autoplay_ && element_->paused_ && element_->Autoplay();
+}
+
+DEFINE_TRACE(AutoplayPolicy) {
+  visitor->Trace(element_);
+  visitor->Trace(autoplay_visibility_observer_);
+  visitor->Trace(autoplay_uma_helper_);
+}
+
+}  // namespace blink