Remove newMediaPlaybackUi flag from content/ and Blink.

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 114 matching lines @@
           this,
           WTF::bind(&MediaControls::hideAllMenus, wrapWeakPersistent(this)))),
       m_hideMediaControlsTimer(this,
                                &MediaControls::hideMediaControlsTimerFired),
       m_hideTimerBehaviorFlags(IgnoreNone),
       m_isMouseOverControls(false),
       m_isPausedForScrubbing(false),
       m_panelWidthChangedTimer(this,
                                &MediaControls::panelWidthChangedTimerFired),
       m_panelWidth(0),
-      m_allowHiddenVolumeControls(
-          RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()),
       m_keepShowingUntilTimerFires(false) {}
 
 MediaControls* MediaControls::create(HTMLMediaElement& mediaElement) {
   MediaControls* controls = new MediaControls(mediaElement);
   controls->setShadowPseudoId(AtomicString("-webkit-media-controls"));
   controls->initializeControls();
   return controls;
 }
 
 // The media controls DOM structure looks like:
 //
 // MediaControls
 //     (-webkit-media-controls)
 // +-MediaControlOverlayEnclosureElement
 // |    (-webkit-media-controls-overlay-enclosure)
 // | +-MediaControlOverlayPlayButtonElement
 // | |    (-webkit-media-controls-overlay-play-button)
 // | | {if mediaControlsOverlayPlayButtonEnabled}
 // | \-MediaControlCastButtonElement
 // |     (-internal-media-controls-overlay-cast-button)
 // \-MediaControlPanelEnclosureElement
 //   |    (-webkit-media-controls-enclosure)
 //   \-MediaControlPanelElement
 //     |    (-webkit-media-controls-panel)
 //     +-MediaControlPlayButtonElement
 //     |    (-webkit-media-controls-play-button)
-//     | {if !RTE::newMediaPlaybackUi()}
-//     +-MediaControlTimelineElement
-//     |    (-webkit-media-controls-timeline)
 //     +-MediaControlCurrentTimeDisplayElement
 //     |    (-webkit-media-controls-current-time-display)
 //     +-MediaControlTimeRemainingDisplayElement
 //     |    (-webkit-media-controls-time-remaining-display)
-//     | {if RTE::newMediaPlaybackUi()}
 //     +-MediaControlTimelineElement
 //     |    (-webkit-media-controls-timeline)
 //     +-MediaControlMuteButtonElement
 //     |    (-webkit-media-controls-mute-button)
 //     +-MediaControlVolumeSliderElement
 //     |    (-webkit-media-controls-volume-slider)
 //     +-MediaControlFullscreenButtonElement
 //     |    (-webkit-media-controls-fullscreen-button)
 //     +-MediaControlDownloadButtonElement
 //     |    (-internal-media-controls-download-button)
 //     +-MediaControlToggleClosedCaptionsButtonElement
 //     |    (-webkit-media-controls-toggle-closed-captions-button)
 //     \-MediaControlCastButtonElement
 //         (-internal-media-controls-cast-button)
 // +-MediaControlTextTrackListElement
 // |    (-internal-media-controls-text-track-list)
 // | {for each renderable text track}
 //  \-MediaControlTextTrackListItem
 //  |   (-internal-media-controls-text-track-list-item)
 //  +-MediaControlTextTrackListItemInput
 //  |    (-internal-media-controls-text-track-list-item-input)
 //  +-MediaControlTextTrackListItemCaptions
 //  |    (-internal-media-controls-text-track-list-kind-captions)
 //  +-MediaControlTextTrackListItemSubtitles
 //       (-internal-media-controls-text-track-list-kind-subtitles)
 void MediaControls::initializeControls() {
-  const bool useNewUi = RuntimeEnabledFeatures::newMediaPlaybackUiEnabled();
   MediaControlOverlayEnclosureElement* overlayEnclosure =
       MediaControlOverlayEnclosureElement::create(*this);
 
   if (document().settings() &&
       document().settings()->mediaControlsOverlayPlayButtonEnabled()) {
     MediaControlOverlayPlayButtonElement* overlayPlayButton =
         MediaControlOverlayPlayButtonElement::create(*this);
     m_overlayPlayButton = overlayPlayButton;
     overlayEnclosure->appendChild(overlayPlayButton);
   }
@@ skipping 11 matching lines @@
   MediaControlPanelEnclosureElement* enclosure =
       MediaControlPanelEnclosureElement::create(*this);
 
   MediaControlPanelElement* panel = MediaControlPanelElement::create(*this);
 
   MediaControlPlayButtonElement* playButton =
       MediaControlPlayButtonElement::create(*this);
   m_playButton = playButton;
   panel->appendChild(playButton);
 
-  MediaControlTimelineElement* timeline =
-      MediaControlTimelineElement::create(*this);
-  m_timeline = timeline;
-  // In old UX, timeline is before the time / duration text.
-  if (!useNewUi)
-    panel->appendChild(timeline);
-  // else we will attach it later.
-
   MediaControlCurrentTimeDisplayElement* currentTimeDisplay =
       MediaControlCurrentTimeDisplayElement::create(*this);
   m_currentTimeDisplay = currentTimeDisplay;
-  m_currentTimeDisplay->setIsWanted(useNewUi);
+  m_currentTimeDisplay->setIsWanted(true);
   panel->appendChild(currentTimeDisplay);
 
   MediaControlTimeRemainingDisplayElement* durationDisplay =
       MediaControlTimeRemainingDisplayElement::create(*this);
   m_durationDisplay = durationDisplay;
   panel->appendChild(durationDisplay);
 
-  // Timeline is after the time / duration text if newMediaPlaybackUiEnabled.
-  if (useNewUi)
-    panel->appendChild(timeline);
+  MediaControlTimelineElement* timeline =
+      MediaControlTimelineElement::create(*this);
+  m_timeline = timeline;
+  panel->appendChild(timeline);
 
   MediaControlMuteButtonElement* muteButton =
       MediaControlMuteButtonElement::create(*this);
   m_muteButton = muteButton;
   panel->appendChild(muteButton);
 
   MediaControlVolumeSliderElement* slider =
       MediaControlVolumeSliderElement::create(*this);
   m_volumeSlider = slider;
   panel->appendChild(slider);
-  if (m_allowHiddenVolumeControls && preferHiddenVolumeControls(document()))
+  if (preferHiddenVolumeControls(document()))
     m_volumeSlider->setIsWanted(false);
 
   MediaControlFullscreenButtonElement* fullscreenButton =
       MediaControlFullscreenButtonElement::create(*this);
   m_fullscreenButton = fullscreenButton;
   panel->appendChild(fullscreenButton);
 
   MediaControlDownloadButtonElement* downloadButton =
       MediaControlDownloadButtonElement::create(*this);
   m_downloadButton = downloadButton;
@@ skipping 44 matching lines @@
       *this, MediaControlMuteButtonElement::create(*this)));
   m_overflowList->appendChild(m_castButton->createOverflowElement(
       *this, MediaControlCastButtonElement::create(*this, false)));
   m_overflowList->appendChild(
       m_toggleClosedCaptionsButton->createOverflowElement(
           *this, MediaControlToggleClosedCaptionsButtonElement::create(*this)));
 }
 
 void MediaControls::reset() {
   EventDispatchForbiddenScope::AllowUserAgentEvents allowEventsInShadow;
-  const bool useNewUi = RuntimeEnabledFeatures::newMediaPlaybackUiEnabled();
   BatchedControlUpdate batch(this);
 
-  m_allowHiddenVolumeControls = useNewUi;
-
   const double duration = mediaElement().duration();
   m_durationDisplay->setTextContent(
       LayoutTheme::theme().formatMediaControlsTime(duration));
   m_durationDisplay->setCurrentValue(duration);
 
-  if (useNewUi) {
-    // Show everything that we might hide.
-    // If we don't have a duration, then mark it to be hidden.  For the
-    // old UI case, want / don't want is the same as show / hide since
-    // it is never marked as not fitting.
-    m_durationDisplay->setIsWanted(std::isfinite(duration));
-    m_currentTimeDisplay->setIsWanted(true);
-    m_timeline->setIsWanted(true);
-  }
+  // Show everything that we might hide.
+  // If we don't have a duration, then mark it to be hidden.  For the
+  // old UI case, want / don't want is the same as show / hide since
+  // it is never marked as not fitting.
+  m_durationDisplay->setIsWanted(std::isfinite(duration));
+  m_currentTimeDisplay->setIsWanted(true);
+  m_timeline->setIsWanted(true);
 
   // If the player has entered an error state, force it into the paused state.
   if (mediaElement().error())
     mediaElement().pause();
 
   updatePlayState();
 
   updateCurrentTimeDisplay();
 
   m_timeline->setDuration(duration);
@@ skipping 82 matching lines @@
 
   // Don't hide the media controls when a panel is showing.
   if (m_textTrackList->isWanted() || m_overflowList->isWanted())
     return false;
 
   return true;
 }
 
 void MediaControls::playbackStarted() {
   BatchedControlUpdate batch(this);
-
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()) {
-    m_currentTimeDisplay->setIsWanted(true);
-    m_durationDisplay->setIsWanted(false);
-  }
-
   updatePlayState();
   m_timeline->setPosition(mediaElement().currentTime());
   updateCurrentTimeDisplay();
 
   startHideMediaControlsTimer();
 }
 
 void MediaControls::playbackProgressed() {
   m_timeline->setPosition(mediaElement().currentTime());
   updateCurrentTimeDisplay();
@@ skipping 32 matching lines @@
     m_isPausedForScrubbing = false;
     if (mediaElement().paused())
       mediaElement().play();
   }
 }
 
 void MediaControls::updateCurrentTimeDisplay() {
   double now = mediaElement().currentTime();
   double duration = mediaElement().duration();
 
-  // After seek, hide duration display and show current time.
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled() && now > 0) {
-    BatchedControlUpdate batch(this);
-    m_currentTimeDisplay->setIsWanted(true);
-    m_durationDisplay->setIsWanted(false);
-  }
-
   // Allow the theme to format the time.
   m_currentTimeDisplay->setInnerText(
       LayoutTheme::theme().formatMediaControlsCurrentTime(now, duration),
       IGNORE_EXCEPTION);
   m_currentTimeDisplay->setCurrentValue(now);
 }
 
 void MediaControls::updateVolume() {
   m_muteButton->updateDisplayType();
   // Invalidate the mute button because it paints differently according to
   // volume.
   invalidate(m_muteButton);
 
   if (mediaElement().muted())
     m_volumeSlider->setVolume(0);
   else
     m_volumeSlider->setVolume(mediaElement().volume());
 
   // Update the visibility of our audio elements.
   // We never want the volume slider if there's no audio.
-  // If there is audio, then we want it unless hiding audio is enabled and
-  // we prefer to hide it.
+  // If there is audio, then we want it unless we prefer to hide it.
   BatchedControlUpdate batch(this);
-  m_volumeSlider->setIsWanted(
-      mediaElement().hasAudio() &&
-      !(m_allowHiddenVolumeControls && preferHiddenVolumeControls(document())));
+  m_volumeSlider->setIsWanted(mediaElement().hasAudio() &&
+                              !preferHiddenVolumeControls(document()));
 
-  // The mute button is a little more complicated.  If enableNewMediaPlaybackUi
-  // is true, then we choose to hide or show the mute button to save space.
-  // If enableNew* is not set, then we never touch the mute button, and
-  // instead leave it to the CSS.
-  // Note that this is why m_allowHiddenVolumeControls isn't rolled into
-  // prefer...().
-  if (m_allowHiddenVolumeControls) {
-    // If there is no audio track, then hide the mute button.
-    m_muteButton->setIsWanted(mediaElement().hasAudio());
-  }
+  // If there is no audio track, then hide the mute button.
+  m_muteButton->setIsWanted(mediaElement().hasAudio());
 
   // Invalidate the volume slider because it paints differently according to
   // volume.
   invalidate(m_volumeSlider);
 }
 
 void MediaControls::changedClosedCaptionsVisibility() {
   m_toggleClosedCaptionsButton->updateDisplayType();
 }
 
@@ skipping 41 matching lines @@
     // visibility in the case where the cast button isn't wanted.
     // We don't call compute...() here, but it will be called as
     // non-cast changes (e.g., resize) occur.  If the panel button
     // is shown, however, compute...() will take control of the
     // overlay cast button if it needs to hide it from the panel.
     m_overlayCastButton->tryShowOverlay();
     m_castButton->setIsWanted(false);
   } else if (mediaElement().shouldShowControls()) {
     m_overlayCastButton->setIsWanted(false);
     m_castButton->setIsWanted(true);
-    // Check that the cast button actually fits on the bar.  For the
-    // newMediaPlaybackUiEnabled case, we let computeWhichControlsFit()
-    // handle this.
-    if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled() &&
-        m_fullscreenButton->getBoundingClientRect()->right() >
-            m_panel->getBoundingClientRect()->right()) {
-      m_castButton->setIsWanted(false);
-      m_overlayCastButton->tryShowOverlay();
-    }
   }
 }
 
 void MediaControls::showOverlayCastButtonIfNeeded() {
   if (mediaElement().shouldShowControls() ||
       !shouldShowCastButton(mediaElement()))
     return;
 
   m_overlayCastButton->tryShowOverlay();
   resetHideMediaControlsTimer();
@@ skipping 130 matching lines @@
   return contains(relatedTarget->toNode());
 }
 
 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.
   // 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.
-  const int panelWidth = newWidth.toInt();
-
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled())
-    return;
-
-  m_panelWidth = panelWidth;
+  m_panelWidth = newWidth.toInt();
 
   // 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);
 }
 
 void MediaControls::panelWidthChangedTimerFired(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.
 
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled())
-    return;
-
   // 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(),
@@ skipping 84 matching lines @@
         width += sliderMargin;
       if (usedWidth + width <= m_panelWidth)
         firstDisplacedElement->setDoesFit(true);
     }
   } else if (overflowElements.size() == 1) {
     m_overflowMenu->setIsWanted(false);
     overflowElements.front()->setDoesFit(true);
   }
 }
 
-void MediaControls::setAllowHiddenVolumeControls(bool allow) {
-  m_allowHiddenVolumeControls = allow;
-  // Update the controls visibility.
-  updateVolume();
-}
-
 void MediaControls::invalidate(Element* element) {
   if (!element)
     return;
 
   if (LayoutObject* layoutObject = element->layoutObject())
     layoutObject
         ->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 }
 
 void MediaControls::networkStateChanged() {
@@ skipping 45 matching lines @@
   visitor->trace(m_textTrackList);
   visitor->trace(m_overflowMenu);
   visitor->trace(m_overflowList);
   visitor->trace(m_castButton);
   visitor->trace(m_overlayCastButton);
   visitor->trace(m_windowEventListener);
   HTMLDivElement::trace(visitor);
 }
 
 }  // namespace blink