Detect change on the intersection of video and viewport.

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 21 matching lines @@
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/HTMLNames.h"
 #include "core/css/MediaList.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ElementVisibilityObserver.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/IntersectionGeometry.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/AutoplayUmaHelper.h"
 #include "core/html/HTMLMediaSource.h"
@@ skipping 66 matching lines @@
 namespace blink {
 
 using namespace HTMLNames;
 
 using WeakMediaElementSet = HeapHashSet<WeakMember<HTMLMediaElement>>;
 using DocumentElementSetMap =
     HeapHashMap<WeakMember<Document>, Member<WeakMediaElementSet>>;
 
 namespace {
 
+constexpr float kMostlyFillViewportThreshold = 0.85f;
+constexpr double kMostlyFillViewportBecomeStableSeconds = 5;
+
 enum MediaControlsShow {
   MediaControlsShowAttribute = 0,
   MediaControlsShowFullscreen,
   MediaControlsShowNoScript,
   MediaControlsShowNotShown,
   MediaControlsShowMax
 };
 
 String urlForLoggingMedia(const KURL& url) {
   static const unsigned maximumURLLengthForLogging = 128;
@@ skipping 199 matching lines @@
 HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName,
                                    Document& document)
     : HTMLElement(tagName, document),
       ActiveScriptWrappable(this),
       ActiveDOMObject(&document),
       m_loadTimer(this, &HTMLMediaElement::loadTimerFired),
       m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired),
       m_playbackProgressTimer(this,
                               &HTMLMediaElement::playbackProgressTimerFired),
       m_audioTracksTimer(this, &HTMLMediaElement::audioTracksTimerFired),
+      m_viewportFillDebouncerTimer(
+          this,
+          &HTMLMediaElement::viewportFillDebouncerTimerFired),
       m_playedTimeRanges(),
       m_asyncEventQueue(GenericEventQueue::create(this)),
       m_playbackRate(1.0f),
       m_defaultPlaybackRate(1.0f),
       m_networkState(kNetworkEmpty),
       m_readyState(kHaveNothing),
       m_readyStateMaximum(kHaveNothing),
       m_volume(1.0f),
       m_lastSeekTime(0),
       m_previousProgressTime(std::numeric_limits<double>::max()),
@@ skipping 19 matching lines @@
       m_paused(true),
       m_seeking(false),
       m_sentStalledEvent(false),
       m_ignorePreloadNone(false),
       m_textTracksVisible(false),
       m_shouldPerformAutomaticTrackSelection(true),
       m_tracksAreReady(true),
       m_processingPreferenceChange(false),
       m_playingRemotely(false),
       m_inOverlayFullscreenVideo(false),
+      m_mostlyFillingViewport(false),
       m_audioTracks(this, AudioTrackList::create(*this)),
       m_videoTracks(this, VideoTrackList::create(*this)),
       m_textTracks(this, nullptr),
       m_audioSourceNode(nullptr),
       m_autoplayUmaHelper(AutoplayUmaHelper::create(this)),
       m_remotePlaybackClient(nullptr),
       m_autoplayVisibilityObserver(nullptr) {
   ThreadState::current()->registerPreFinalizer(this);
 
   BLINK_MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
@@ skipping 723 matching lines @@
 
   m_webMediaPlayer->setPreload(effectivePreloadType());
 
   m_webMediaPlayer->requestRemotePlaybackDisabled(
       fastHasAttribute(disableremoteplaybackAttr));
 
   m_webMediaPlayer->load(loadType(), source, corsMode());
 
   if (isFullscreen())
     m_webMediaPlayer->enteredFullscreen();
+
+  m_webMediaPlayer->becameDominantVisibleContent(m_mostlyFillingViewport);
 }
 
 void HTMLMediaElement::setPlayerPreload() {
   if (m_webMediaPlayer)
     m_webMediaPlayer->setPreload(effectivePreloadType());
 
   if (loadIsDeferred() && effectivePreloadType() != WebMediaPlayer::PreloadNone)
     startDeferredLoad();
 }
 
@@ skipping 1262 matching lines @@
 void HTMLMediaElement::startPlaybackProgressTimer() {
   if (m_playbackProgressTimer.isActive())
     return;
 
   m_previousProgressTime = WTF::currentTime();
   m_playbackProgressTimer.startRepeating(maxTimeupdateEventFrequency,
                                          BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::playbackProgressTimerFired(TimerBase*) {
+  checkViewportIntersectionChanged();
+
   if (!std::isnan(m_fragmentEndTime) && currentTime() >= m_fragmentEndTime &&
       getDirectionOfPlayback() == Forward) {
     m_fragmentEndTime = std::numeric_limits<double>::quiet_NaN();
     if (!m_paused) {
       UseCounter::count(document(),
                         UseCounter::HTMLMediaElementPauseAtFragmentEnd);
       // changes paused to true and fires a simple event named pause at the
       // media element.
       pauseInternal();
     }
@@ skipping 1605 matching lines @@
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioClientImpl) {
   visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl) {
   visitor->trace(m_client);
 }
 
+void HTMLMediaElement::checkViewportIntersectionChanged() {
+  // TODO(xjz): Early return if we not in tab mirroring.
+
+  IntersectionGeometry geometry(
+      &document(), this, Vector<Length>(),
+      IntersectionGeometry::ReportRootBounds::kShouldReportRootBounds);
+  geometry.computeGeometry();
+  IntRect intersectRect = geometry.intersectionIntRect();
+  if (m_currentIntersectRect == intersectRect)
+    return;
+
+  m_currentIntersectRect = intersectRect;
+  // Reset on any intersection change, since this indicates the user is
+  // scrolling around in the document, the document is changing layout, etc.
+  m_viewportFillDebouncerTimer.stop();
+  bool isMostlyFillingViewport =
+      (m_currentIntersectRect.size().area() >
+       kMostlyFillViewportThreshold * geometry.rootIntRect().size().area());
+  if (m_mostlyFillingViewport == isMostlyFillingViewport)
+    return;
+
+  if (!isMostlyFillingViewport) {
+    m_mostlyFillingViewport = isMostlyFillingViewport;
+    if (m_webMediaPlayer)
+      m_webMediaPlayer->becameDominantVisibleContent(m_mostlyFillingViewport);
+    return;
+  }
+
+  m_viewportFillDebouncerTimer.startOneShot(
+      kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
+}
+
+void HTMLMediaElement::viewportFillDebouncerTimerFired(TimerBase*) {
+  m_mostlyFillingViewport = true;
+  if (m_webMediaPlayer)
+    m_webMediaPlayer->becameDominantVisibleContent(m_mostlyFillingViewport);
+}
+
 }  // namespace blink