Remove all "new" suffixes from media player assets.

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 27 matching lines @@
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
 static const double kCurrentTimeBufferedDelta = 1.0;
 
 typedef WTF::HashMap<const char*, Image*> MediaControlImageMap;
 static MediaControlImageMap* gMediaControlImageMap = 0;
 
 // 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;
+static const int mediaSliderThumbTouchWidth = 36;  // Touch zone size.
+static const int mediaSliderThumbTouchHeight = 48;
+static const int mediaSliderThumbPaintWidth = 12;  // Painted area.
+static const int mediaSliderThumbPaintHeight = 12;
 
 // Overlay play button size.
-static const int mediaOverlayPlayButtonWidthNew = 48;
-static const int mediaOverlayPlayButtonHeightNew = 48;
+static const int mediaOverlayPlayButtonWidth = 48;
+static const int mediaOverlayPlayButtonHeight = 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()) {
@@ skipping 55 matching lines @@
   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("mediaplayerSoundLevel3New");
-  static Image* soundLevel2 = platformResource("mediaplayerSoundLevel3New");
-  static Image* soundLevel1 = platformResource("mediaplayerSoundLevel3New");
-  static Image* soundLevel0 = platformResource("mediaplayerSoundLevel0New");
-  static Image* soundDisabled = platformResource("mediaplayerSoundLevel0New");
+  static Image* soundNotMuted = platformResource("mediaplayerSoundNotMuted");
+  static Image* soundMuted = platformResource("mediaplayerSoundMuted");
 
-  if (!hasSource(mediaElement) || !mediaElement->hasAudio())
-    return paintMediaButton(paintInfo.context, rect, soundDisabled, &object,
+  if (!hasSource(mediaElement) || !mediaElement->hasAudio()) {
+    return paintMediaButton(paintInfo.context, rect, soundMuted, &object,
                             false);
+  }
 
   if (mediaElement->muted() || mediaElement->volume() <= 0)
-    return paintMediaButton(paintInfo.context, rect, soundLevel0, &object,
-                            true);
+    return paintMediaButton(paintInfo.context, rect, soundMuted, &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);
+  return paintMediaButton(paintInfo.context, rect, soundNotMuted, &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("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("mediaplayerPlayNew");
+  static Image* mediaPlay = platformResource("mediaplayerPlay");
+  static Image* mediaPause = platformResource("mediaplayerPause");
 
+  // Draw the regular play button grayed out.
   if (!hasSource(mediaElement))
-    return paintMediaButton(paintInfo.context, rect, mediaPlayDisabled, &object,
-                            false);
+    return paintMediaButton(paintInfo.context, rect, mediaPlay, &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("mediaplayerOverlayPlayNew");
+  static Image* mediaOverlayPlay = platformResource("mediaplayerOverlayPlay");
 
   IntRect buttonRect(rect);
 
   // 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 +
+  buttonRect.setX(rect.center().x() - mediaOverlayPlayButtonWidth / 2);
+  buttonRect.setY(rect.center().y() - mediaOverlayPlayButtonHeight / 2 +
                   (mediaHeight - rect.height()) / 2);
-  buttonRect.setWidth(mediaOverlayPlayButtonWidthNew);
-  buttonRect.setHeight(mediaOverlayPlayButtonHeightNew);
+  buttonRect.setWidth(mediaOverlayPlayButtonWidth);
+  buttonRect.setHeight(mediaOverlayPlayButtonHeight);
 
   return paintMediaButton(paintInfo.context, buttonRect, mediaOverlayPlay);
 }
 
 static void paintRoundedSliderBackground(const IntRect& rect,
                                          const ComputedStyle& style,
                                          GraphicsContext& context,
                                          Color sliderBackgroundColor) {
   float borderRadius = rect.height() / 2;
   FloatSize radii(borderRadius, borderRadius);
@@ skipping 153 matching lines @@
     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;
 
   const float zoomLevel = style.effectiveZoom();
-  const float zoomedPaintWidth = mediaSliderThumbPaintWidthNew * zoomLevel;
-  const float zoomedPaintHeight = mediaSliderThumbPaintHeightNew * zoomLevel;
+  const float zoomedPaintWidth = mediaSliderThumbPaintWidth * zoomLevel;
+  const float zoomedPaintHeight = mediaSliderThumbPaintHeight * 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;
 
-  static Image* mediaSliderThumb =
-      platformResource("mediaplayerSliderThumbNew");
+  static Image* mediaSliderThumb = platformResource("mediaplayerSliderThumb");
   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);
@@ skipping 34 matching lines @@
 
   const HTMLMediaElement* mediaElement =
       toParentMediaElement(object.node()->ownerShadowHost());
   if (!mediaElement)
     return false;
 
   if (!hasSource(mediaElement) || !mediaElement->hasAudio())
     return true;
 
   static Image* mediaVolumeSliderThumb =
-      platformResource("mediaplayerVolumeSliderThumbNew");
+      platformResource("mediaplayerVolumeSliderThumb");
 
   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("mediaplayerEnterFullscreen");
   static Image* mediaExitFullscreenButton =
       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);
+  Image* image =
+      (mediaControlElementType(object.node()) == MediaExitFullscreenButton)
+          ? mediaExitFullscreenButton
+          : mediaEnterFullscreenButton;
+  const bool isEnabled = hasSource(mediaElement);
+  return paintMediaButton(paintInfo.context, rect, image, &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("mediaplayerClosedCaptionNew");
+      platformResource("mediaplayerClosedCaption");
   static Image* mediaClosedCaptionButtonDisabled =
-      platformResource("mediaplayerClosedCaptionDisabledNew");
+      platformResource("mediaplayerClosedCaptionDisabled");
 
-  bool isEnabled = mediaElement->hasClosedCaptions();
-
-  if (mediaElement->textTracksVisible())
-    return paintMediaButton(paintInfo.context, rect, mediaClosedCaptionButton,
-                            &object, isEnabled);
-
-  return paintMediaButton(paintInfo.context, rect,
-                          mediaClosedCaptionButtonDisabled, &object, isEnabled);
+  Image* image = mediaElement->textTracksVisible()
+                     ? mediaClosedCaptionButton
+                     : mediaClosedCaptionButtonDisabled;
+  const bool isEnabled = mediaElement->hasClosedCaptions();
+  return paintMediaButton(paintInfo.context, rect, image, &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("mediaplayerCastOnNew");
-  static Image* mediaCastOff = platformResource("mediaplayerCastOffNew");
+  static Image* mediaCastOn = platformResource("mediaplayerCastOn");
+  static Image* mediaCastOff = platformResource("mediaplayerCastOff");
   // 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("mediaplayerOverlayCastOffNew");
+      platformResource("mediaplayerOverlayCastOff");
 
   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("mediaplayerTrackSelectionCheckmarkNew");
+      platformResource("mediaplayerTrackSelectionCheckmark");
   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("mediaplayerClosedCaptionsIconNew");
+      platformResource("mediaplayerClosedCaptionsIcon");
   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("mediaplayerSubtitlesIconNew");
+      platformResource("mediaplayerSubtitlesIcon");
   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 13 matching lines @@
   bool isEnabled = hasSource(mediaElement);
 
   static Image* mediaDownloadIcon = platformResource("mediaplayerDownloadIcon");
   return paintMediaButton(paintInfo.context, rect, mediaDownloadIcon, &object,
                           isEnabled);
 }
 
 void MediaControlsPainter::adjustMediaSliderThumbSize(ComputedStyle& style) {
   const float zoomLevel = style.effectiveZoom();
 
-  style.setWidth(Length(
-      static_cast<int>(mediaSliderThumbTouchWidthNew * zoomLevel), Fixed));
-  style.setHeight(Length(
-      static_cast<int>(mediaSliderThumbTouchHeightNew * zoomLevel), Fixed));
+  style.setWidth(
+      Length(static_cast<int>(mediaSliderThumbTouchWidth * zoomLevel), Fixed));
+  style.setHeight(
+      Length(static_cast<int>(mediaSliderThumbTouchHeight * zoomLevel), Fixed));
 }
 
 }  // namespace blink