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;
+
+constexpr int kMinWidthForOverlayPlayButton = kOverlayPlayButtonWidth;
+constexpr int kMinHeightForOverlayPlayButton = kOverlayPlayButtonHeight +
+                                               (2 * kAndroidMediaPanelHeight) +
+                                               (2 * kOverlayBottomMargin);
+}  // 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

[whywhat, 2017/02/23 21:37:31]

nit: could you add a comment to the forward declarations in the header that
they're needed for private member access?

[steimel, 2017/02/24 00:42:43]

Done.

+    : 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());

[whywhat, 2017/02/23 21:37:31]

nit: DCHECK entries[0]->target() is m_mediaElement?

[steimel, 2017/02/24 00:42:43]

Done.

+    ClientRect* contentRect = entries[0]->contentRect();
+    m_controls->notifyElementSizeChanged(contentRect->width(),
+                                         contentRect->height());
+  }
+
+  DEFINE_INLINE_TRACE() {
+    visitor->trace(m_controls);
+    ResizeObserverCallback::trace(visitor);
+  }
+
+ private:
+  Member<MediaControls> m_controls;
+};
+
 MediaControls::MediaControls(HTMLMediaElement& mediaElement)
     : HTMLDivElement(mediaElement.document()),
+      m_resizeObserver(ResizeObserver::create(
+          mediaElement.document(),
+          new MediaControlsResizeObserverCallback(this))),
       m_mediaElement(&mediaElement),
       m_overlayEnclosure(nullptr),
       m_overlayPlayButton(nullptr),
       m_overlayCastButton(nullptr),
       m_enclosure(nullptr),
       m_panel(nullptr),
       m_playButton(nullptr),
       m_timeline(nullptr),
       m_currentTimeDisplay(nullptr),
       m_durationDisplay(nullptr),
@@ skipping 10 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_elementSizeChangedTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer,

[whywhat, 2017/02/23 21:37:32]

rant: I'm sad unspeced is used as a word (however internal search reveals it's
being used sometimes).

[steimel, 2017/02/24 00:42:43]

Acknowledged :)

+                                                      &mediaElement.document()),
+                                this,
+                                &MediaControls::elementSizeChangedTimerFired),
+      m_elementWidth(0),
+      m_elementHeight(0),
+      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) {
+void MediaControls::notifyElementSizeChanged(int newWidth, int newHeight) {
   // Don't bother to do any work if this matches the most recent panel
-  // width, since we're called after layout.
+  // size, since we're called after layout.

[whywhat, 2017/02/23 21:37:31]

nit: I'm not sure this comment is up-to-date, I don't see any check for the
width/height to match the known ones.

[steimel, 2017/02/24 00:42:43]

You're right. At some point, I guess that logic was moved to LayoutMedia, though
in this patchset that has been removed to be handled by the ResizeObserver.
However, in the next patchset (in order to address your comment below) the logic
will be re-added here at the bottom of this method. I'll move this comment
there.

   // 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();
+  m_elementWidth = newWidth;
+  m_elementHeight = newHeight;
+  m_sizingInitialized = true;
 
   // Adjust for effective zoom.
   if (!m_panel->layoutObject() || !m_panel->layoutObject()->style())
     return;
-  m_panelWidth =
-      ceil(m_panelWidth / m_panel->layoutObject()->style()->effectiveZoom());
 
-  m_panelWidthChangedTimer.startOneShot(0, BLINK_FROM_HERE);
+  m_elementWidth =

[whywhat, 2017/02/23 21:37:31]

is it still the element's width or panel's width after the computation?
is it possible the new value of m_elementWidth is the same as the one used
before the resize event after this computation (so we get the event but don't
need to do anything since from the panel size perspective nothing changed)?

[steimel, 2017/02/24 00:42:43]

Those are both good points. For the first, I've changed the member to be called
|m_effective(Width|Height)|. For the second, I've added the logic for not firing
the size-change timer if the effectiveWidth hasn't changed. This also brings up
whether or not we need to worry about effectiveZoom for height. I assume the
height is affected in the same manner as the width, but since the height is only
used for the clipping calculation, which (at least currently) depends on
fixed-pixel-calculation that may be affected by the zoom as well, not sure if
it's necessary. I'm happy to look into it though

+      ceil(m_elementWidth / m_panel->layoutObject()->style()->effectiveZoom());
+
+  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_elementWidth) {
     // 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_elementWidth) {
         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_elementWidth)
         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_elementWidth && m_elementHeight && m_overlayPlayButton) {
+    bool doesFit = m_elementWidth >= kMinWidthForOverlayPlayButton &&
+                   m_elementHeight >= kMinHeightForOverlayPlayButton;
+    m_overlayPlayButton->setDoesFit(doesFit);
+  }
 }
 
 void MediaControls::invalidate(Element* element) {
   if (!element)
     return;
 
   if (LayoutObject* layoutObject = element->layoutObject())
     layoutObject
         ->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 }
 
 void MediaControls::networkStateChanged() {
   invalidate(m_playButton);
   invalidate(m_overlayPlayButton);
   invalidate(m_muteButton);
   invalidate(m_fullscreenButton);
   invalidate(m_downloadButton);
   invalidate(m_timeline);
   invalidate(m_volumeSlider);
 }
 
+void MediaControls::onLayout(int width, int height) {
+  if (!m_sizingInitialized) {

[whywhat, 2017/02/23 21:37:31]

nit: no need for {}

I wish we could somehow request the size in the ctor before registering the
ResizeObserver but I guess it's not feasible.

[steimel, 2017/02/24 00:42:43]

Right. I had tried to initialize in the ctor (and then in initializeControls),
however in order to get the size, I had to force a layout, which was breaking a
unit test that depended on a layout *not* occurring on initialization
(MediaControlsTest.ResetDoesNotTriggerInitialLayout). If not forcing a layout on
initialization is *not* a necessary restriction, then I can revisit that

+    notifyElementSizeChanged(width, height);
+  }
+}
+
 bool MediaControls::overflowMenuVisible() {
   return m_overflowList ? m_overflowList->isWanted() : false;
 }
 
 void MediaControls::toggleOverflowMenu() {
   DCHECK(m_overflowList);
 
   if (!m_overflowList->isWanted())
     m_windowEventListener->start();
   m_overflowList->setIsWanted(!m_overflowList->isWanted());
 }
 
 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