Remove newMediaPlaybackUi flag from content/ and Blink.

third_party/WebKit/Source/core/paint/MediaControlsPainter.cpp

 /*
  * Copyright (C) 2009 Apple Inc.
  * Copyright (C) 2009 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.
@@ skipping 26 matching lines @@
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
 static const double kCurrentTimeBufferedDelta = 1.0;
 
 typedef WTF::HashMap<const char*, Image*> MediaControlImageMap;
 static MediaControlImageMap* gMediaControlImageMap = 0;
 
-// Current UI slider thumbs sizes.
-static const int mediaSliderThumbWidth = 32;
-static const int mediaSliderThumbHeight = 24;
-static const int mediaVolumeSliderThumbHeight = 24;
-static const int mediaVolumeSliderThumbWidth = 24;
-
-// New UI slider thumb sizes, shard between time and volume.
+// Slider thumb sizes, shard between time and volume.
 static const int mediaSliderThumbTouchWidthNew = 36;  // Touch zone size.
 static const int mediaSliderThumbTouchHeightNew = 48;
 static const int mediaSliderThumbPaintWidthNew = 12;  // Painted area.
 static const int mediaSliderThumbPaintHeightNew = 12;
 
-// New UI overlay play button size.
+// Overlay play button size.
 static const int mediaOverlayPlayButtonWidthNew = 48;
 static const int mediaOverlayPlayButtonHeightNew = 48;
 
 // Alpha for disabled elements.
 static const float kDisabledAlpha = 0.4;
 
 static Image* platformResource(const char* name) {
   if (!gMediaControlImageMap)
     gMediaControlImageMap = new MediaControlImageMap();
   if (Image* image = gMediaControlImageMap->get(name))
     return image;
   if (Image* image = Image::loadPlatformResource(name).leakRef()) {
     gMediaControlImageMap->set(name, image);
     return image;
   }
   ASSERT_NOT_REACHED();
   return 0;
 }
 
-static Image* platformResource(const char* currentName, const char* newName) {
-  // Return currentName or newName based on current or new playback.
-  return platformResource(RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()
-                              ? newName
-                              : currentName);
-}
-
 static bool hasSource(const HTMLMediaElement* mediaElement) {
   return mediaElement->getNetworkState() != HTMLMediaElement::kNetworkEmpty &&
          mediaElement->getNetworkState() != HTMLMediaElement::kNetworkNoSource;
 }
 
 static FloatRect adjustRectForPadding(IntRect rect,
                                       const LayoutObject* object) {
   FloatRect adjustedRect(rect);
 
   if (!object)
@@ skipping 11 matching lines @@
   }
 
   return adjustedRect;
 }
 
 static bool paintMediaButton(GraphicsContext& context,
                              const IntRect& rect,
                              Image* image,
                              const LayoutObject* object,
                              bool isEnabled) {
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()) {
-    context.drawImage(image, rect);
-    return true;
-  }
-
   FloatRect drawRect = adjustRectForPadding(rect, object);
 
   if (!isEnabled)
     context.beginLayer(kDisabledAlpha);
 
   context.drawImage(image, drawRect);
 
   if (!isEnabled)
     context.endLayer();
 
   return true;
 }
 
 static bool paintMediaButton(GraphicsContext& context,
                              const IntRect& rect,
                              Image* image,
                              bool isEnabled = true) {
   return paintMediaButton(context, rect, image, 0, isEnabled);
 }
 
 bool MediaControlsPainter::paintMediaMuteButton(const LayoutObject& object,
                                                 const PaintInfo& paintInfo,
                                                 const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
   // The new UI uses "muted" and "not muted" only.
-  static Image* soundLevel3 =
-      platformResource("mediaplayerSoundLevel3", "mediaplayerSoundLevel3New");
-  static Image* soundLevel2 =
-      platformResource("mediaplayerSoundLevel2", "mediaplayerSoundLevel3New");
-  static Image* soundLevel1 =
-      platformResource("mediaplayerSoundLevel1", "mediaplayerSoundLevel3New");
-  static Image* soundLevel0 =
-      platformResource("mediaplayerSoundLevel0", "mediaplayerSoundLevel0New");
-  static Image* soundDisabled =
-      platformResource("mediaplayerSoundDisabled", "mediaplayerSoundLevel0New");
+  static Image* soundLevel3 = platformResource("mediaplayerSoundLevel3New");
+  static Image* soundLevel2 = platformResource("mediaplayerSoundLevel3New");
+  static Image* soundLevel1 = platformResource("mediaplayerSoundLevel3New");
+  static Image* soundLevel0 = platformResource("mediaplayerSoundLevel0New");
+  static Image* soundDisabled = platformResource("mediaplayerSoundLevel0New");
 
   if (!hasSource(mediaElement) || !mediaElement->hasAudio())
     return paintMediaButton(paintInfo.context, rect, soundDisabled, &object,
                             false);
 
   if (mediaElement->muted() || mediaElement->volume() <= 0)
     return paintMediaButton(paintInfo.context, rect, soundLevel0, &object,
                             true);
 
   if (mediaElement->volume() <= 0.33)
     return paintMediaButton(paintInfo.context, rect, soundLevel1, &object,
                             true);
 
   if (mediaElement->volume() <= 0.66)
     return paintMediaButton(paintInfo.context, rect, soundLevel2, &object,
                             true);
 
   return paintMediaButton(paintInfo.context, rect, soundLevel3, &object, true);
 }
 
 bool MediaControlsPainter::paintMediaPlayButton(const LayoutObject& object,
                                                 const PaintInfo& paintInfo,
                                                 const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
-  static Image* mediaPlay =
-      platformResource("mediaplayerPlay", "mediaplayerPlayNew");
-  static Image* mediaPause =
-      platformResource("mediaplayerPause", "mediaplayerPauseNew");
+  static Image* mediaPlay = platformResource("mediaplayerPlayNew");
+  static Image* mediaPause = platformResource("mediaplayerPauseNew");
   // For this case, the new UI draws the normal icon, but the entire panel
   // grays out.
-  static Image* mediaPlayDisabled =
-      platformResource("mediaplayerPlayDisabled", "mediaplayerPlayNew");
+  static Image* mediaPlayDisabled = platformResource("mediaplayerPlayNew");
 
   if (!hasSource(mediaElement))
     return paintMediaButton(paintInfo.context, rect, mediaPlayDisabled, &object,
                             false);
 
   Image* image =
       !object.node()->isMediaControlElement() ||
               mediaControlElementType(object.node()) == MediaPlayButton
           ? mediaPlay
           : mediaPause;
   return paintMediaButton(paintInfo.context, rect, image, &object, true);
 }
 
 bool MediaControlsPainter::paintMediaOverlayPlayButton(
     const LayoutObject& object,
     const PaintInfo& paintInfo,
     const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
   if (!hasSource(mediaElement) || !mediaElement->paused())
     return false;
 
   static Image* mediaOverlayPlay =
-      platformResource("mediaplayerOverlayPlay", "mediaplayerOverlayPlayNew");
+      platformResource("mediaplayerOverlayPlayNew");
 
   IntRect buttonRect(rect);
-  if (RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()) {
-    // Overlay play button covers the entire player, so center and draw a
-    // smaller button.  Center in the entire element.
-    // TODO(liberato): object.enclosingBox()?
-    const LayoutBox* box = mediaElement->layoutObject()->enclosingBox();
-    if (!box)
-      return false;
-    int mediaHeight = box->pixelSnappedHeight();
-    buttonRect.setX(rect.center().x() - mediaOverlayPlayButtonWidthNew / 2);
-    buttonRect.setY(rect.center().y() - mediaOverlayPlayButtonHeightNew / 2 +
-                    (mediaHeight - rect.height()) / 2);
-    buttonRect.setWidth(mediaOverlayPlayButtonWidthNew);
-    buttonRect.setHeight(mediaOverlayPlayButtonHeightNew);
-  }
+
+  // Overlay play button covers the entire player, so center and draw a
+  // smaller button.  Center in the entire element.
+  // TODO(liberato): object.enclosingBox()?
+  const LayoutBox* box = mediaElement->layoutObject()->enclosingBox();
+  if (!box)
+    return false;
+  int mediaHeight = box->pixelSnappedHeight();
+  buttonRect.setX(rect.center().x() - mediaOverlayPlayButtonWidthNew / 2);
+  buttonRect.setY(rect.center().y() - mediaOverlayPlayButtonHeightNew / 2 +
+                  (mediaHeight - rect.height()) / 2);
+  buttonRect.setWidth(mediaOverlayPlayButtonWidthNew);
+  buttonRect.setHeight(mediaOverlayPlayButtonHeightNew);
 
   return paintMediaButton(paintInfo.context, buttonRect, mediaOverlayPlay);
 }
 
-static Image* getMediaSliderThumb() {
-  static Image* mediaSliderThumb =
-      platformResource("mediaplayerSliderThumb", "mediaplayerSliderThumbNew");
-  return mediaSliderThumb;
-}
-
 static void paintRoundedSliderBackground(const IntRect& rect,
                                          const ComputedStyle& style,
                                          GraphicsContext& context,
                                          Color sliderBackgroundColor) {
   float borderRadius = rect.height() / 2;
   FloatSize radii(borderRadius, borderRadius);
 
   context.fillRoundedRect(FloatRoundedRect(rect, radii, radii, radii, radii),
                           sliderBackgroundColor);
 }
@@ skipping 66 matching lines @@
 bool MediaControlsPainter::paintMediaSlider(const LayoutObject& object,
                                             const PaintInfo& paintInfo,
                                             const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
   GraphicsContext& context = paintInfo.context;
 
   // Should we paint the slider partially transparent?
-  bool drawUiGrayed = !hasSource(mediaElement) &&
-                      RuntimeEnabledFeatures::newMediaPlaybackUiEnabled();
+  bool drawUiGrayed = !hasSource(mediaElement);
   if (drawUiGrayed)
     context.beginLayer(kDisabledAlpha);
 
   paintMediaSliderInternal(object, paintInfo, rect);
 
   if (drawUiGrayed)
     context.endLayer();
 
   return true;
 }
 
 void MediaControlsPainter::paintMediaSliderInternal(const LayoutObject& object,
                                                     const PaintInfo& paintInfo,
                                                     const IntRect& rect) {
-  const bool useNewUi = RuntimeEnabledFeatures::newMediaPlaybackUiEnabled();
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return;
 
   const ComputedStyle& style = object.styleRef();
   GraphicsContext& context = paintInfo.context;
 
   // Paint the slider bar in the "no data buffered" state.
-  Color sliderBackgroundColor;
-  if (!useNewUi)
-    sliderBackgroundColor = Color(11, 11, 11);
-  else
-    sliderBackgroundColor = Color(0xda, 0xda, 0xda);
-
-  paintRoundedSliderBackground(rect, style, context, sliderBackgroundColor);
+  paintRoundedSliderBackground(rect, style, context, Color(0xda, 0xda, 0xda));
 
   // Draw the buffered range. Since the element may have multiple buffered
   // ranges and it'd be distracting/'busy' to show all of them, show only the
   // buffered range containing the current play head.
   TimeRanges* bufferedTimeRanges = mediaElement->buffered();
   float duration = mediaElement->duration();
   float currentTime = mediaElement->currentTime();
   if (std::isnan(duration) || std::isinf(duration) || !duration ||
       std::isnan(currentTime))
     return;
 
   for (unsigned i = 0; i < bufferedTimeRanges->length(); ++i) {
     float start = bufferedTimeRanges->start(i, ASSERT_NO_EXCEPTION);
     float end = bufferedTimeRanges->end(i, ASSERT_NO_EXCEPTION);
     // The delta is there to avoid corner cases when buffered
     // ranges is out of sync with current time because of
     // asynchronous media pipeline and current time caching in
     // HTMLMediaElement.
     // This is related to https://www.w3.org/Bugs/Public/show_bug.cgi?id=28125
     // FIXME: Remove this workaround when WebMediaPlayer
     // has an asynchronous pause interface.
     if (std::isnan(start) || std::isnan(end) ||
         start > currentTime + kCurrentTimeBufferedDelta || end < currentTime)
       continue;
     int startPosition = int(start * rect.width() / duration);
     int currentPosition = int(currentTime * rect.width() / duration);
     int endPosition = int(end * rect.width() / duration);
 
-    if (!useNewUi) {
-      // Add half the thumb width proportionally adjusted to the current
-      // painting position.
-      int thumbCenter = mediaSliderThumbWidth / 2;
-      int addWidth = thumbCenter * (1.0 - 2.0 * currentPosition / rect.width());
-      currentPosition += addWidth;
+    // Draw highlight before current time.
+    Color startColor = Color(0x42, 0x85, 0xf4);
+    Color endColor = Color(0x42, 0x85, 0xf4);
+
+    if (currentPosition > startPosition) {
+      paintSliderRangeHighlight(rect, style, context, startPosition,
+                                currentPosition, startColor, endColor);
     }
 
-    // Draw highlight before current time.
-    Color startColor;
-    Color endColor;
-    if (!useNewUi) {
-      startColor = Color(195, 195, 195);  // white-ish.
-      endColor = Color(217, 217, 217);
-    } else {
-      startColor = endColor = Color(0x42, 0x85, 0xf4);  // blue.
-    }
+    // Draw dark grey highlight after current time.
+    startColor = endColor = Color(0x5a, 0x5a, 0x5a);
 
-    if (currentPosition > startPosition)
-      paintSliderRangeHighlight(rect, style, context, startPosition,
-                                currentPosition, startColor, endColor);
-
-    // Draw grey-ish highlight after current time.
-    if (!useNewUi) {
-      startColor = Color(60, 60, 60);
-      endColor = Color(76, 76, 76);
-    } else {
-      startColor = endColor = Color(0x5a, 0x5a, 0x5a);  // dark grey
-    }
-
-    if (endPosition > currentPosition)
+    if (endPosition > currentPosition) {
       paintSliderRangeHighlight(rect, style, context, currentPosition,
                                 endPosition, startColor, endColor);
-
+    }
     return;
   }
 }
 
 void MediaControlsPainter::adjustMediaSliderThumbPaintSize(
     const IntRect& rect,
     const ComputedStyle& style,
     IntRect& rectOut) {
   // Adjust the rectangle to be centered, the right size for the image.
   // We do this because it's quite hard to get the thumb touch target
   // to match.  So, we provide the touch target size with
   // adjustMediaSliderThumbSize(), and scale it back when we paint.
   rectOut = rect;
 
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()) {
-    // ...except for the old UI.
-    return;
-  }
-
-  float zoomLevel = style.effectiveZoom();
-  float zoomedPaintWidth = mediaSliderThumbPaintWidthNew * zoomLevel;
-  float zoomedPaintHeight = mediaSliderThumbPaintHeightNew * zoomLevel;
+  const float zoomLevel = style.effectiveZoom();
+  const float zoomedPaintWidth = mediaSliderThumbPaintWidthNew * zoomLevel;
+  const float zoomedPaintHeight = mediaSliderThumbPaintHeightNew * zoomLevel;
 
   rectOut.setX(rect.center().x() - zoomedPaintWidth / 2);
   rectOut.setY(rect.center().y() - zoomedPaintHeight / 2);
   rectOut.setWidth(zoomedPaintWidth);
   rectOut.setHeight(zoomedPaintHeight);
 }
 
 bool MediaControlsPainter::paintMediaSliderThumb(const LayoutObject& object,
                                                  const PaintInfo& paintInfo,
                                                  const IntRect& rect) {
   if (!object.node())
     return false;
 
   const HTMLMediaElement* mediaElement =
       toParentMediaElement(object.node()->ownerShadowHost());
   if (!mediaElement)
     return false;
 
   if (!hasSource(mediaElement))
     return true;
 
-  Image* mediaSliderThumb = getMediaSliderThumb();
+  static Image* mediaSliderThumb =
+      platformResource("mediaplayerSliderThumbNew");
   IntRect paintRect;
   const ComputedStyle& style = object.styleRef();
   adjustMediaSliderThumbPaintSize(rect, style, paintRect);
   return paintMediaButton(paintInfo.context, paintRect, mediaSliderThumb);
 }
 
 bool MediaControlsPainter::paintMediaVolumeSlider(const LayoutObject& object,
                                                   const PaintInfo& paintInfo,
                                                   const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
   GraphicsContext& context = paintInfo.context;
   const ComputedStyle& style = object.styleRef();
 
   // Paint the slider bar.
-  Color sliderBackgroundColor;
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled())
-    sliderBackgroundColor = Color(11, 11, 11);
-  else
-    sliderBackgroundColor = Color(0x5a, 0x5a, 0x5a);  // dark grey
-  paintRoundedSliderBackground(rect, style, context, sliderBackgroundColor);
+  paintRoundedSliderBackground(rect, style, context, Color(0x5a, 0x5a, 0x5a));
 
   // Calculate volume position for white background rectangle.
   float volume = mediaElement->volume();
   if (std::isnan(volume) || volume < 0)
     return true;
   if (volume > 1)
     volume = 1;
   if (!hasSource(mediaElement) || !mediaElement->hasAudio() ||
       mediaElement->muted())
     volume = 0;
 
   // Calculate the position relative to the center of the thumb.
-  float fillWidth = 0;
-  if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()) {
-    if (volume > 0) {
-      float thumbCenter = mediaVolumeSliderThumbWidth / 2;
-      float zoomLevel = style.effectiveZoom();
-      float positionWidth = volume * (rect.width() - (zoomLevel * thumbCenter));
-      fillWidth = positionWidth + (zoomLevel * thumbCenter / 2);
-    }
-  } else {
-    fillWidth = volume * rect.width();
-  }
-
-  Color startColor = Color(195, 195, 195);
-  Color endColor = Color(217, 217, 217);
-  if (RuntimeEnabledFeatures::newMediaPlaybackUiEnabled())
-    startColor = endColor = Color(0x42, 0x85, 0xf4);  // blue.
-
+  const float fillWidth = volume * rect.width();
+  static const Color startColor = Color(0x42, 0x85, 0xf4);
+  static const Color endColor = Color(217, 217, 217);
   paintSliderRangeHighlight(rect, style, context, 0.0, fillWidth, startColor,
                             endColor);
 
   return true;
 }
 
 bool MediaControlsPainter::paintMediaVolumeSliderThumb(
     const LayoutObject& object,
     const PaintInfo& paintInfo,
     const IntRect& rect) {
   if (!object.node())
     return false;
 
   const HTMLMediaElement* mediaElement =
       toParentMediaElement(object.node()->ownerShadowHost());
   if (!mediaElement)
     return false;
 
   if (!hasSource(mediaElement) || !mediaElement->hasAudio())
     return true;
 
-  static Image* mediaVolumeSliderThumb = platformResource(
-      "mediaplayerVolumeSliderThumb", "mediaplayerVolumeSliderThumbNew");
+  static Image* mediaVolumeSliderThumb =
+      platformResource("mediaplayerVolumeSliderThumbNew");
 
   IntRect paintRect;
   const ComputedStyle& style = object.styleRef();
   adjustMediaSliderThumbPaintSize(rect, style, paintRect);
   return paintMediaButton(paintInfo.context, paintRect, mediaVolumeSliderThumb);
 }
 
 bool MediaControlsPainter::paintMediaFullscreenButton(
     const LayoutObject& object,
     const PaintInfo& paintInfo,
     const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
   // With the new player UI, we have separate assets for enter / exit
   // fullscreen mode.
   static Image* mediaEnterFullscreenButton =
-      platformResource("mediaplayerFullscreen", "mediaplayerEnterFullscreen");
+      platformResource("mediaplayerEnterFullscreen");
   static Image* mediaExitFullscreenButton =
-      platformResource("mediaplayerFullscreen", "mediaplayerExitFullscreen");
+      platformResource("mediaplayerExitFullscreen");
 
   bool isEnabled = hasSource(mediaElement);
 
   if (mediaControlElementType(object.node()) == MediaExitFullscreenButton)
     return paintMediaButton(paintInfo.context, rect, mediaExitFullscreenButton,
                             &object, isEnabled);
   return paintMediaButton(paintInfo.context, rect, mediaEnterFullscreenButton,
                           &object, isEnabled);
 }
 
 bool MediaControlsPainter::paintMediaToggleClosedCaptionsButton(
     const LayoutObject& object,
     const PaintInfo& paintInfo,
     const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
-  static Image* mediaClosedCaptionButton = platformResource(
-      "mediaplayerClosedCaption", "mediaplayerClosedCaptionNew");
+  static Image* mediaClosedCaptionButton =
+      platformResource("mediaplayerClosedCaptionNew");
   static Image* mediaClosedCaptionButtonDisabled =
-      platformResource("mediaplayerClosedCaptionDisabled",
-                       "mediaplayerClosedCaptionDisabledNew");
+      platformResource("mediaplayerClosedCaptionDisabledNew");
 
   bool isEnabled = mediaElement->hasClosedCaptions();
 
   if (mediaElement->textTracksVisible())
     return paintMediaButton(paintInfo.context, rect, mediaClosedCaptionButton,
                             &object, isEnabled);
 
   return paintMediaButton(paintInfo.context, rect,
                           mediaClosedCaptionButtonDisabled, &object, isEnabled);
 }
 
 bool MediaControlsPainter::paintMediaCastButton(const LayoutObject& object,
                                                 const PaintInfo& paintInfo,
                                                 const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
-  static Image* mediaCastOn =
-      platformResource("mediaplayerCastOn", "mediaplayerCastOnNew");
-  static Image* mediaCastOff =
-      platformResource("mediaplayerCastOff", "mediaplayerCastOffNew");
+  static Image* mediaCastOn = platformResource("mediaplayerCastOnNew");
+  static Image* mediaCastOff = platformResource("mediaplayerCastOffNew");
   // To ensure that the overlaid cast button is visible when overlaid on pale
   // videos we use a different version of it for the overlaid case with a
   // semi-opaque background.
-  static Image* mediaOverlayCastOff = platformResource(
-      "mediaplayerOverlayCastOff", "mediaplayerOverlayCastOffNew");
+  static Image* mediaOverlayCastOff =
+      platformResource("mediaplayerOverlayCastOffNew");
 
   bool isEnabled = mediaElement->hasRemoteRoutes();
 
   switch (mediaControlElementType(object.node())) {
     case MediaCastOnButton:
       return paintMediaButton(paintInfo.context, rect, mediaCastOn, &object,
                               isEnabled);
     case MediaOverlayCastOnButton:
       return paintMediaButton(paintInfo.context, rect, mediaCastOn);
     case MediaCastOffButton:
       return paintMediaButton(paintInfo.context, rect, mediaCastOff, &object,
                               isEnabled);
     case MediaOverlayCastOffButton:
       return paintMediaButton(paintInfo.context, rect, mediaOverlayCastOff);
     default:
       ASSERT_NOT_REACHED();
       return false;
   }
 }
 
 bool MediaControlsPainter::paintMediaTrackSelectionCheckmark(
     const LayoutObject& object,
     const PaintInfo& paintInfo,
     const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
   static Image* mediaTrackSelectionCheckmark =
-      platformResource("mediaplayerTrackSelectionCheckmark",
-                       "mediaplayerTrackSelectionCheckmarkNew");
+      platformResource("mediaplayerTrackSelectionCheckmarkNew");
   return paintMediaButton(paintInfo.context, rect,
                           mediaTrackSelectionCheckmark);
 }
 
 bool MediaControlsPainter::paintMediaClosedCaptionsIcon(
     const LayoutObject& object,
     const PaintInfo& paintInfo,
     const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
-  static Image* mediaClosedCaptionsIcon = platformResource(
-      "mediaplayerClosedCaptionsIcon", "mediaplayerClosedCaptionsIconNew");
+  static Image* mediaClosedCaptionsIcon =
+      platformResource("mediaplayerClosedCaptionsIconNew");
   return paintMediaButton(paintInfo.context, rect, mediaClosedCaptionsIcon);
 }
 
 bool MediaControlsPainter::paintMediaSubtitlesIcon(const LayoutObject& object,
                                                    const PaintInfo& paintInfo,
                                                    const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
-  static Image* mediaSubtitlesIcon = platformResource(
-      "mediaplayerSubtitlesIcon", "mediaplayerSubtitlesIconNew");
+  static Image* mediaSubtitlesIcon =
+      platformResource("mediaplayerSubtitlesIconNew");
   return paintMediaButton(paintInfo.context, rect, mediaSubtitlesIcon);
 }
 
 bool MediaControlsPainter::paintMediaOverflowMenu(const LayoutObject& object,
                                                   const PaintInfo& paintInfo,
                                                   const IntRect& rect) {
   const HTMLMediaElement* mediaElement = toParentMediaElement(object);
   if (!mediaElement)
     return false;
 
@@ skipping 11 matching lines @@
     return false;
 
   bool isEnabled = hasSource(mediaElement);
 
   static Image* mediaDownloadIcon = platformResource("mediaplayerDownloadIcon");
   return paintMediaButton(paintInfo.context, rect, mediaDownloadIcon, &object,
                           isEnabled);
 }
 
 void MediaControlsPainter::adjustMediaSliderThumbSize(ComputedStyle& style) {
-  static Image* mediaSliderThumb =
-      platformResource("mediaplayerSliderThumb", "mediaplayerSliderThumbNew");
-  static Image* mediaVolumeSliderThumb = platformResource(
-      "mediaplayerVolumeSliderThumb", "mediaplayerVolumeSliderThumbNew");
-  int width = 0;
-  int height = 0;
+  const float zoomLevel = style.effectiveZoom();
 
-  Image* thumbImage = 0;
-
-  if (RuntimeEnabledFeatures::newMediaPlaybackUiEnabled()) {
-    // Volume and time sliders are the same.
-    thumbImage = mediaSliderThumb;
-    width = mediaSliderThumbTouchWidthNew;
-    height = mediaSliderThumbTouchHeightNew;
-  } else if (style.appearance() == MediaSliderThumbPart) {
-    thumbImage = mediaSliderThumb;
-    width = mediaSliderThumbWidth;
-    height = mediaSliderThumbHeight;
-  } else if (style.appearance() == MediaVolumeSliderThumbPart) {
-    thumbImage = mediaVolumeSliderThumb;
-    width = mediaVolumeSliderThumbWidth;
-    height = mediaVolumeSliderThumbHeight;
-  }
-
-  float zoomLevel = style.effectiveZoom();
-  if (thumbImage) {
-    style.setWidth(Length(static_cast<int>(width * zoomLevel), Fixed));
-    style.setHeight(Length(static_cast<int>(height * zoomLevel), Fixed));
-  }
+  style.setWidth(Length(
+      static_cast<int>(mediaSliderThumbTouchWidthNew * zoomLevel), Fixed));
+  style.setHeight(Length(
+      static_cast<int>(mediaSliderThumbTouchHeightNew * zoomLevel), Fixed));
 }
 
 }  // namespace blink