Autoplay: use an autoplay policy setting in Blink.

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) {
+bool IsDocumentCrossOrigin(const Document& document) {
   const LocalFrame* frame = document.GetFrame();
   return frame && frame->IsCrossOriginSubframe();
 }
 
 // Returns whether |document| is whitelisted for autoplay. If true, the user
 // gesture lock will be initilized as false, indicating that the element is
 // allowed to autoplay unmuted without user gesture.
-bool IsDocumentWhitelisted(Document& document) {
+bool IsDocumentWhitelisted(const Document& document) {
   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;
+bool ComputeLockedPendingUserGesture(const Document& document) {
+  switch (AutoplayPolicy::GetAutoplayPolicyForDocument(document)) {
+    case AutoplayPolicy::Type::kNoUserGestureRequired:
+      return false;
+    case AutoplayPolicy::Type::kUserGestureRequiredForCrossOrigin:
+      return IsDocumentCrossOrigin(document);
+    case AutoplayPolicy::Type::kUserGestureRequired:
+      return true;
   }
 
-  if (document.GetSettings()
-          ->GetCrossOriginMediaPlaybackRequiresUserGesture() &&
-      IsDocumentCrossOrigin(document)) {
-    return true;
-  }
-
-  return document.GetSettings()->GetMediaPlaybackRequiresUserGesture();
+  NOTREACHED();
+  return true;
 }
 
 }  // anonymous namespace
 
+// static
+AutoplayPolicy::Type AutoplayPolicy::GetAutoplayPolicyForDocument(
+    const Document& document) {
+  if (!document.GetSettings())
+    return Type::kNoUserGestureRequired;
+
+  if (IsDocumentWhitelisted(document))
+    return Type::kNoUserGestureRequired;
+
+  return document.GetSettings()->GetAutoplayPolicy();
+}
+
 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());
@@ skipping 220 matching lines @@
   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