Hide overlay play button if it can't be shown without clipping

third_party/WebKit/Source/core/html/shadow/MediaControls.cpp

 /*
  * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, 2012 Google 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 11 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/shadow/MediaControls.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/ResizeObserver.h"
+#include "core/dom/ResizeObserverCallback.h"
+#include "core/dom/ResizeObserverEntry.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/shadow/MediaControlsMediaEventListener.h"
 #include "core/html/shadow/MediaControlsOrientationLockDelegate.h"
 #include "core/html/shadow/MediaControlsWindowEventListener.h"
 #include "core/html/track/TextTrackContainer.h"
 #include "core/html/track/TextTrackList.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
 #include "platform/EventDispatchForbiddenScope.h"
 
 namespace blink {
 
+namespace {
+
+constexpr int kOverlayPlayButtonWidth = 48;
+constexpr int kOverlayPlayButtonHeight = 48;
+constexpr int kOverlayBottomMargin = 10;
+constexpr int kAndroidMediaPanelHeight = 48;
+
+// If these change, they must also be changed in
+// LayoutTests/virtual/android/media/controls/overlay-play-button-narrow.html.
+constexpr int kMinWidthForOverlayPlayButton = kOverlayPlayButtonWidth;
+constexpr int kMinHeightForOverlayPlayButton = kOverlayPlayButtonHeight +
+                                               (2 * kAndroidMediaPanelHeight) +
+                                               (2 * kOverlayBottomMargin);
+
+}  // anonymous namespace
+
 // If you change this value, then also update the corresponding value in
 // LayoutTests/media/media-controls.js.
 static const double timeWithoutMouseMovementBeforeHidingMediaControls = 3;
 
 static bool shouldShowFullscreenButton(const HTMLMediaElement& mediaElement) {
   // Unconditionally allow the user to exit fullscreen if we are in it
   // now.  Especially on android, when we might not yet know if
   // fullscreen is supported, we sometimes guess incorrectly and show
   // the button earlier, and we don't want to remove it here if the
   // user chose to enter fullscreen.  crbug.com/500732 .
@@ skipping 49 matching lines @@
   }
 
  private:
   Member<MediaControls> m_controls;
   static int s_batchDepth;
 };
 
 // Count of number open batches for controls visibility.
 int MediaControls::BatchedControlUpdate::s_batchDepth = 0;
 
+class MediaControls::MediaControlsResizeObserverCallback final
+    : public ResizeObserverCallback {
+ public:
+  explicit MediaControlsResizeObserverCallback(MediaControls* controls)
+      : m_controls(controls) {
+    DCHECK(controls);
+  }
+  ~MediaControlsResizeObserverCallback() override = default;
+
+  void handleEvent(const HeapVector<Member<ResizeObserverEntry>>& entries,
+                   ResizeObserver* observer) override {
+    DCHECK_EQ(1u, entries.size());
+    DCHECK_EQ(entries[0]->target(), m_controls->m_mediaElement);
+    m_controls->notifyElementSizeChanged(entries[0]->contentRect());
+  }
+
+  DEFINE_INLINE_TRACE() {
+    visitor->trace(m_controls);
+    ResizeObserverCallback::trace(visitor);
+  }
+
+ private:
+  Member<MediaControls> m_controls;
+};
+
 MediaControls::MediaControls(HTMLMediaElement& mediaElement)
     : HTMLDivElement(mediaElement.document()),
       m_mediaElement(&mediaElement),
       m_overlayEnclosure(nullptr),
       m_overlayPlayButton(nullptr),
       m_overlayCastButton(nullptr),
       m_enclosure(nullptr),
       m_panel(nullptr),
       m_playButton(nullptr),
       m_timeline(nullptr),
@@ skipping 12 matching lines @@
           this,
           WTF::bind(&MediaControls::hideAllMenus, wrapWeakPersistent(this)))),
       m_orientationLockDelegate(nullptr),
       m_hideMediaControlsTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer,
                                                      &mediaElement.document()),
                                this,
                                &MediaControls::hideMediaControlsTimerFired),
       m_hideTimerBehaviorFlags(IgnoreNone),
       m_isMouseOverControls(false),
       m_isPausedForScrubbing(false),
-      m_panelWidthChangedTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer,
-                                                     &mediaElement.document()),
-                               this,
-                               &MediaControls::panelWidthChangedTimerFired),
-      m_panelWidth(0),
-      m_keepShowingUntilTimerFires(false) {}
+      m_resizeObserver(ResizeObserver::create(

[mlamouri (slow - plz ping), 2017/03/02 13:56:50]

I've just added a `onInsertedIntoDocument` and `onRemovedFromDocument` callback
to MediaControls. Do you mind removing/adding back the observer using this
callbacks. It might be useful to make sure we don't break things when changing
document. You might want to add a test for this too because I think your change
will regress this. You can see an example at
LayoutTests/media/autoplay-document-move.html

+          mediaElement.document(),
+          new MediaControlsResizeObserverCallback(this))),
+      m_elementSizeChangedTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer,
+                                                      &mediaElement.document()),
+                                this,
+                                &MediaControls::elementSizeChangedTimerFired),
+      m_keepShowingUntilTimerFires(false) {
+  m_resizeObserver->observe(m_mediaElement);
+}
 
 MediaControls* MediaControls::create(HTMLMediaElement& mediaElement,
                                      ShadowRoot& shadowRoot) {
   MediaControls* controls = new MediaControls(mediaElement);
   controls->setShadowPseudoId(AtomicString("-webkit-media-controls"));
   controls->initializeControls();
   controls->reset();
 
   // Initialize the orientation lock when going fullscreen feature.
   if (RuntimeEnabledFeatures::videoFullscreenOrientationLockEnabled() &&
@@ skipping 616 matching lines @@
   stopHideMediaControlsTimer();
   startHideMediaControlsTimer();
 }
 
 void MediaControls::onExitedFullscreen() {
   m_fullscreenButton->setIsFullscreen(false);
   stopHideMediaControlsTimer();
   startHideMediaControlsTimer();
 }
 
-void MediaControls::notifyPanelWidthChanged(const LayoutUnit& newWidth) {
-  // Don't bother to do any work if this matches the most recent panel
-  // width, since we're called after layout.
+void MediaControls::notifyElementSizeChanged(ClientRect* newSize) {
   // Note that this code permits a bad frame on resize, since it is
   // run after the relayout / paint happens.  It would be great to improve
   // this, but it would be even greater to move this code entirely to
   // JS and fix it there.
-  m_panelWidth = newWidth.toInt();
+
+  IntSize oldSize = m_size;
+  m_size.setWidth(newSize->width());
+  m_size.setHeight(newSize->height());
 
   // Adjust for effective zoom.
-  if (!m_panel->layoutObject() || !m_panel->layoutObject()->style())
-    return;
-  m_panelWidth =
-      ceil(m_panelWidth / m_panel->layoutObject()->style()->effectiveZoom());
+  if (m_panel->layoutObject() && m_panel->layoutObject()->style()) {
+    m_size.setWidth(ceil(m_size.width() /
+                         m_panel->layoutObject()->style()->effectiveZoom()));
+    m_size.setHeight(ceil(m_size.height() /
+                          m_panel->layoutObject()->style()->effectiveZoom()));
+  }
 
-  m_panelWidthChangedTimer.startOneShot(0, BLINK_FROM_HERE);
+  // Don't bother to do any work if this matches the most recent size.
+  if (oldSize != m_size)
+    m_elementSizeChangedTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
-void MediaControls::panelWidthChangedTimerFired(TimerBase*) {
+void MediaControls::elementSizeChangedTimerFired(TimerBase*) {
   computeWhichControlsFit();
 }
 
 void MediaControls::computeWhichControlsFit() {
   // Hide all controls that don't fit, and show the ones that do.
   // This might be better suited for a layout, but since JS media controls
   // won't benefit from that anwyay, we just do it here like JS will.
 
   // Controls that we'll hide / show, in order of decreasing priority.
   MediaControlElement* elements[] = {
       // Exclude m_overflowMenu; we handle it specially.
       m_playButton.get(),
       m_fullscreenButton.get(),
       m_downloadButton.get(),
       m_timeline.get(),
       m_muteButton.get(),
       m_volumeSlider.get(),
       m_toggleClosedCaptionsButton.get(),
       m_castButton.get(),
       m_currentTimeDisplay.get(),
       m_durationDisplay.get(),
   };
 
   // TODO(mlamouri): we need a more dynamic way to find out the width of an
   // element.
   const int sliderMargin = 36;  // Sliders have 18px margin on each side.
 
-  if (!m_panelWidth) {
+  if (!m_size.width()) {
     // No layout yet -- hide everything, then make them show up later.
     // This prevents the wrong controls from being shown briefly
     // immediately after the first layout and paint, but before we have
     // a chance to revise them.
     for (MediaControlElement* element : elements) {
       if (element)
         element->setDoesFit(false);
     }
     return;
   }
@@ skipping 24 matching lines @@
   MediaControlElement* firstDisplacedElement = nullptr;
   // For each control that fits, enable it in order of decreasing priority.
   for (MediaControlElement* element : elements) {
     if (!element)
       continue;
     int width = minimumWidth;
     if ((element == m_timeline.get()) || (element == m_volumeSlider.get()))
       width += sliderMargin;
     element->shouldShowButtonInOverflowMenu(false);
     if (element->isWanted()) {
-      if (usedWidth + width <= m_panelWidth) {
+      if (usedWidth + width <= m_size.width()) {
         element->setDoesFit(true);
         usedWidth += width;
       } else {
         element->setDoesFit(false);
         element->shouldShowButtonInOverflowMenu(true);
         if (element->hasOverflowButton())
           overflowElements.push_front(element);
         // We want a way to access the first media element that was
         // removed. If we don't end up needing an overflow menu, we can
         // use the space the overflow menu would have taken up to
         // instead display that media element.
         if (!element->hasOverflowButton() && !firstDisplacedElement)
           firstDisplacedElement = element;
       }
     }
   }
 
   // If we don't have at least two overflow elements, we will not show the
   // overflow menu.
   if (overflowElements.empty()) {
     m_overflowMenu->setIsWanted(false);
     usedWidth -= minimumWidth;
     if (firstDisplacedElement) {
       int width = minimumWidth;
       if ((firstDisplacedElement == m_timeline.get()) ||
           (firstDisplacedElement == m_volumeSlider.get()))
         width += sliderMargin;
-      if (usedWidth + width <= m_panelWidth)
+      if (usedWidth + width <= m_size.width())
         firstDisplacedElement->setDoesFit(true);
     }
   } else if (overflowElements.size() == 1) {
     m_overflowMenu->setIsWanted(false);
     overflowElements.front()->setDoesFit(true);
   }
+
+  // Decide if the overlay play button fits.
+  if (m_overlayPlayButton) {
+    bool doesFit = m_size.width() >= kMinWidthForOverlayPlayButton &&
+                   m_size.height() >= kMinHeightForOverlayPlayButton;
+    m_overlayPlayButton->setDoesFit(doesFit);
+  }
 }
 
 void MediaControls::invalidate(Element* element) {
   if (!element)
     return;
 
   if (LayoutObject* layoutObject = element->layoutObject())
     layoutObject
         ->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 }
@@ skipping 23 matching lines @@
 void MediaControls::hideAllMenus() {
   m_windowEventListener->stop();
 
   if (m_overflowList->isWanted())
     m_overflowList->setIsWanted(false);
   if (m_textTrackList->isWanted())
     m_textTrackList->setVisible(false);
 }
 
 DEFINE_TRACE(MediaControls) {
+  visitor->trace(m_resizeObserver);
   visitor->trace(m_mediaElement);
   visitor->trace(m_panel);
   visitor->trace(m_overlayPlayButton);
   visitor->trace(m_overlayEnclosure);
   visitor->trace(m_playButton);
   visitor->trace(m_currentTimeDisplay);
   visitor->trace(m_timeline);
   visitor->trace(m_muteButton);
   visitor->trace(m_volumeSlider);
   visitor->trace(m_toggleClosedCaptionsButton);
   visitor->trace(m_fullscreenButton);
   visitor->trace(m_downloadButton);
   visitor->trace(m_durationDisplay);
   visitor->trace(m_enclosure);
   visitor->trace(m_textTrackList);
   visitor->trace(m_overflowMenu);
   visitor->trace(m_overflowList);
   visitor->trace(m_castButton);
   visitor->trace(m_overlayCastButton);
   visitor->trace(m_mediaEventListener);
   visitor->trace(m_windowEventListener);
   visitor->trace(m_orientationLockDelegate);
   HTMLDivElement::trace(visitor);
 }
 
 }  // namespace blink