Paint media element's play button using padding.

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 70 matching lines @@
     // 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::NETWORK_EMPTY
         && mediaElement->getNetworkState() != HTMLMediaElement::NETWORK_NO_SOURCE;
 }
 
-static bool paintMediaButton(GraphicsContext& context, const IntRect& rect, Image* image, bool isEnabled = true)
+static FloatRect adjustRectForPadding(IntRect rect, const LayoutObject* object)
 {
-    if (!RuntimeEnabledFeatures::newMediaPlaybackUiEnabled())
-        isEnabled = true; // New UI only.
+    FloatRect adjustedRect(rect);
+
+    if (!object)
+        return adjustedRect;
+
+    // TODO(liberato): make this more elegant, crbug.com/598861 .
+    if (const ComputedStyle* style = object->style()) {
+        const float paddingLeft = style->paddingLeft().getFloatValue();
+        const float paddingTop = style->paddingTop().getFloatValue();
+        const float paddingRight = style->paddingRight().getFloatValue();
+        const float paddingBottom = style->paddingBottom().getFloatValue();
+        adjustedRect = FloatRect(rect.x() + paddingLeft,
+            rect.y() + paddingTop,
+            rect.width() - paddingLeft - paddingRight,
+            rect.height() - paddingTop - paddingBottom);
+    }
+
+    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, rect);
+    context.drawImage(image, drawRect, FloatRect(FloatPoint(), FloatSize(image->size())));
 
     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");
 
     if (!hasSource(mediaElement) || !mediaElement->hasAudio())
-        return paintMediaButton(paintInfo.context, rect, soundDisabled, false);
+        return paintMediaButton(paintInfo.context, rect, soundDisabled, &object, false);
 
     if (mediaElement->muted() || mediaElement->volume() <= 0)
-        return paintMediaButton(paintInfo.context, rect, soundLevel0);
+        return paintMediaButton(paintInfo.context, rect, soundLevel0, &object, true);
 
     if (mediaElement->volume() <= 0.33)
-        return paintMediaButton(paintInfo.context, rect, soundLevel1);
+        return paintMediaButton(paintInfo.context, rect, soundLevel1, &object, true);
 
     if (mediaElement->volume() <= 0.66)
-        return paintMediaButton(paintInfo.context, rect, soundLevel2);
+        return paintMediaButton(paintInfo.context, rect, soundLevel2, &object, true);
 
-    return paintMediaButton(paintInfo.context, rect, soundLevel3);
+    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");
     // For this case, the new UI draws the normal icon, but the entire panel
     // grays out.
     static Image* mediaPlayDisabled = platformResource("mediaplayerPlayDisabled", "mediaplayerPlayNew");
 
     if (!hasSource(mediaElement))
-        return paintMediaButton(paintInfo.context, rect, mediaPlayDisabled, false);
+        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);
+    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");
 
     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);
     }
@@ skipping 294 matching lines @@
     static Image* mediaEnterFullscreenButton = platformResource(
         "mediaplayerFullscreen",
         "mediaplayerEnterFullscreen");
     static Image* mediaExitFullscreenButton = platformResource(
         "mediaplayerFullscreen",
         "mediaplayerExitFullscreen");
 
     bool isEnabled = hasSource(mediaElement);
 
     if (mediaControlElementType(object.node()) == MediaExitFullscreenButton)
-        return paintMediaButton(paintInfo.context, rect, mediaExitFullscreenButton, isEnabled);
-    return paintMediaButton(paintInfo.context, rect, mediaEnterFullscreenButton, isEnabled);
+        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* mediaClosedCaptionButtonDisabled = platformResource(
         "mediaplayerClosedCaptionDisabled",
         "mediaplayerClosedCaptionDisabledNew");
 
     bool isEnabled = mediaElement->hasClosedCaptions();
 
     if (mediaElement->textTracksVisible())
-        return paintMediaButton(paintInfo.context, rect, mediaClosedCaptionButton, isEnabled);
+        return paintMediaButton(paintInfo.context, rect, mediaClosedCaptionButton, &object, isEnabled);
 
-    return paintMediaButton(paintInfo.context, rect, mediaClosedCaptionButtonDisabled, 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");
     // 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");
 
     bool isEnabled = mediaElement->hasRemoteRoutes();
 
     switch (mediaControlElementType(object.node())) {
     case MediaCastOnButton:
-        return paintMediaButton(paintInfo.context, rect, mediaCastOn, isEnabled);
+        return paintMediaButton(paintInfo.context, rect, mediaCastOn, &object, isEnabled);
     case MediaOverlayCastOnButton:
         return paintMediaButton(paintInfo.context, rect, mediaCastOn);
     case MediaCastOffButton:
-        return paintMediaButton(paintInfo.context, rect, mediaCastOff, isEnabled);
+        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)
 {
@@ skipping 56 matching lines @@
     }
 
     float zoomLevel = style.effectiveZoom();
     if (thumbImage) {
         style.setWidth(Length(static_cast<int>(width * zoomLevel), Fixed));
         style.setHeight(Length(static_cast<int>(height * zoomLevel), Fixed));
     }
 }
 
 } // namespace blink