[Blink>Media] Add heuristic for dominant video detection for Android

third_party/WebKit/Source/core/html/MediaCustomControlsFullscreenDetector.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/MediaCustomControlsFullscreenDetector.h"
+
+#include "core/dom/DocumentFullscreen.h"
+#include "core/dom/TaskRunnerHelper.h"
+#include "core/events/Event.h"
+#include "core/html/HTMLVideoElement.h"
+#include "core/layout/IntersectionGeometry.h"
+
+namespace blink {
+
+namespace {
+
+constexpr double kCheckFullscreenIntervalSeconds = 1.0f;
+constexpr float kMostlyFillViewportThresholdOfOccupationProportion = 0.85f;
+constexpr float kMostlyFillViewportThresholdOfVisibleProportion = 0.75f;
+
+}  // anonymous namespace
+
+MediaCustomControlsFullscreenDetector::MediaCustomControlsFullscreenDetector(
+    HTMLVideoElement& video)
+    : EventListener(CPPEventListenerType),
+      m_videoElement(video),
+      m_checkViewportIntersectionTimer(
+          TaskRunnerHelper::get(TaskType::Unthrottled, &video.document()),
+          this,
+          &MediaCustomControlsFullscreenDetector::
+              onCheckViewportIntersectionTimerFired) {
+  videoElement().document().addEventListener(
+      EventTypeNames::webkitfullscreenchange, this, true);
+  videoElement().document().addEventListener(EventTypeNames::fullscreenchange,
+                                             this, true);
+
+  videoElement().addEventListener(EventTypeNames::loadedmetadata, this, true);
+}
+
+bool MediaCustomControlsFullscreenDetector::operator==(
+    const EventListener& other) const {
+  return this == &other;
+}
+
+void MediaCustomControlsFullscreenDetector::didMoveToNewDocument(
+    Document& oldDocument) {
+  oldDocument.removeEventListener(EventTypeNames::webkitfullscreenchange, this,
+                                  true);
+  oldDocument.removeEventListener(EventTypeNames::fullscreenchange, this, true);
+
+  videoElement().document().addEventListener(
+      EventTypeNames::webkitfullscreenchange, this, true);
+  videoElement().document().addEventListener(EventTypeNames::fullscreenchange,
+                                             this, true);
+}
+
+bool MediaCustomControlsFullscreenDetector::computeIsDominantVideo(
+    const IntRect& targetRect,
+    const IntRect& rootRect,
+    const IntRect& intersectionRect) {
+  const float xOccupationProportion =
+      1.0f * intersectionRect.width() / rootRect.width();

[xjz, 2017/02/22 18:48:34]

Can rootRect be empty? If not, maybe add DCHECK.

[Zhiqiang Zhang (Slow), 2017/02/23 21:50:55]

Thanks. Now I return false if targetRect or rootRect is empty.

[xjz, 2017/02/23 22:49:46]

I don't see any changes though. :)

[Zhiqiang Zhang (Slow), 2017/02/24 12:03:39]

Sorry, it's a mistake (committed to another checkout). Done.

+  const float yOccupationProportion =
+      1.0f * intersectionRect.height() / rootRect.height();
+
+  // If the viewport is mostly occupied by the video, return true.
+  if (std::min(xOccupationProportion, yOccupationProportion) >=
+      kMostlyFillViewportThresholdOfOccupationProportion) {
+    return true;
+  }
+
+  // If neither of the dimensions of the viewport is mostly occupied by the
+  // video, return false.
+  if (std::max(xOccupationProportion, yOccupationProportion) <
+      kMostlyFillViewportThresholdOfOccupationProportion) {
+    return false;
+  }
+
+  // If the video is mostly visible in the indominant dimension, return true.
+  // Otherwise return false.
+  if (xOccupationProportion > yOccupationProportion) {
+    return targetRect.height() *
+               kMostlyFillViewportThresholdOfVisibleProportion <
+           intersectionRect.height();
+  }
+  return targetRect.width() * kMostlyFillViewportThresholdOfVisibleProportion <
+         intersectionRect.width();
+}
+
+void MediaCustomControlsFullscreenDetector::handleEvent(
+    ExecutionContext* context,
+    Event* event) {
+  DCHECK(event->type() == EventTypeNames::fullscreenchange ||
+         event->type() == EventTypeNames::webkitfullscreenchange ||
+         event->type() == EventTypeNames::loadedmetadata);
+
+  // Video is not loaded yet.
+  if (videoElement().getReadyState() < HTMLMediaElement::kHaveMetadata)
+    return;
+
+  if (!isVideoOrParentFullscreen()) {
+    m_checkViewportIntersectionTimer.stop();
+
+    if (videoElement().webMediaPlayer()) {
+      videoElement().webMediaPlayer()->setEffectivelyFullscreen(false);
+    }
+    return;
+  }
+
+  m_checkViewportIntersectionTimer.startOneShot(kCheckFullscreenIntervalSeconds,
+                                                BLINK_FROM_HERE);
+}
+
+void MediaCustomControlsFullscreenDetector::
+    onCheckViewportIntersectionTimerFired(TimerBase*) {
+  DCHECK(isVideoOrParentFullscreen());
+  IntersectionGeometry geometry(nullptr, videoElement(), Vector<Length>(),
+                                true);
+  geometry.computeGeometry();
+
+  bool isDominant =
+      computeIsDominantVideo(geometry.targetIntRect(), geometry.rootIntRect(),
+                             geometry.intersectionIntRect());
+
+  if (videoElement().webMediaPlayer()) {
+    videoElement().webMediaPlayer()->setEffectivelyFullscreen(isDominant);
+  }
+}
+
+bool MediaCustomControlsFullscreenDetector::isVideoOrParentFullscreen() {
+  return DocumentFullscreen::fullscreenElement(videoElement().document());

[xjz, 2017/02/22 18:48:34]

Can the fullscreen element be the child of the video element? Maybe call this
"hasFullscreenElement"?

ooc, what's the difference between fullscreenElement() and
currentFullscreenElement()? Which one should be used here?

[Zhiqiang Zhang (Slow), 2017/02/23 21:50:55]

This should be rare and we are focusing on the typical use cases at the moment.
We can always iterate if there are some edge cases.
A more proper name is "isDocumentFullscreen".
mlamouri@: should this logic be sufficient? In the very beginning I wanted to
look up in the dom tree and see if any element is the fullscreen element. Now I
just check if the document has fullscreen element.
The other one is asynchronous, but at this point, they should be the same. Also
calling the Fullscreen:: version instead of DocumentFullscreen:: version

[Zhiqiang Zhang (Slow), 2017/02/24 12:03:40]

I reverted back to isVideoOrParentFullscreen(). Now I'm not just checking the
document has fullscreen element, but also check if the fullscreen element is the
video element itself or its ancestor.

[xjz, 2017/02/24 18:30:10]

The logic sgtm. Just ooc, if the video is the current fullscreen element, do you
still need to start timer and check whether it is dominant? The fullscreen might
already be a strong indicator. WDYT?

[Zhiqiang Zhang (Slow), 2017/02/25 18:48:27]

That would bring in several more if-else's. I'd prefer keep the logic simpler.

+}
+
+DEFINE_TRACE(MediaCustomControlsFullscreenDetector) {
+  EventListener::trace(visitor);
+  visitor->trace(m_videoElement);
+}
+
+}  // namespace blink