Refactor shadow rendering logic.

Source/core/rendering/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 16 matching lines @@
 #include "core/dom/DocumentMarkerController.h"
 #include "core/dom/RenderedDocumentMarker.h"
 #include "core/dom/Text.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
 #include "core/editing/Editor.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Frame.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
+#include "core/platform/graphics/DrawLooper.h"
 #include "core/platform/graphics/FontCache.h"
 #include "core/platform/graphics/GraphicsContextStateSaver.h"
 #include "core/rendering/EllipsisBox.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderArena.h"
 #include "core/rendering/RenderBR.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderCombineText.h"
 #include "core/rendering/RenderRubyRun.h"
 #include "core/rendering/RenderRubyText.h"
 #include "core/rendering/RenderTheme.h"
 #include "core/rendering/break_lines.h"
+#include "core/rendering/style/ShadowData.h"
 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
-#include <wtf/text/CString.h>
+#include "wtf/Vector.h"
+#include "wtf/text/CString.h"
 
 using namespace std;
 
 namespace WebCore {
 
 typedef WTF::HashMap<const InlineTextBox*, LayoutRect> InlineTextBoxOverflowMap;
 static InlineTextBoxOverflowMap* gTextBoxesWithOverflow;
 
 static const int misspellingLineThickness = 3;
 
@@ skipping 340 matching lines @@
         FloatRect shadowRect(textRect);
         shadowRect.inflate(shadowBlur);
         shadowRect.move(shadowOffset);
         context->save();
         context->clip(shadowRect);
 
         extraOffset = FloatSize(0, 2 * textRect.height() + max(0.0f, shadowOffset.height()) + shadowBlur);
         shadowOffset -= extraOffset;
     }
 
-    context->setShadow(shadowOffset, shadowBlur, shadowColor, context->fillColorSpace());
+    context->setShadow(shadowOffset, shadowBlur, shadowColor);
     return extraOffset;
 }
 
 static void paintTextWithShadows(GraphicsContext* context, const Font& font, const TextRun& textRun,
                                  const AtomicString& emphasisMark, int emphasisMarkOffset,
                                  int startOffset, int endOffset, int truncationPoint,
                                  const FloatPoint& textOrigin, const FloatRect& boxRect,
                                  const ShadowData* shadow, bool stroked, bool horizontal)
 {
+    bool hasShadow = !!shadow;
     Color fillColor = context->fillColor();
-    ColorSpace fillColorSpace = context->fillColorSpace();
-    bool opaque = fillColor.alpha() == 255;
-    if (!opaque)
-        context->setFillColor(Color::black, fillColorSpace);
+
+    if (hasShadow) {
+        // FIXME: it would be better if we could get the shadows top-to-bottom from the style.
+        Vector<const ShadowData*, 4> shadows;
+        do {
+            shadows.append(shadow);
+        } while (shadow = shadow->next());
+
+        DrawLooper drawLooper;
+        drawLooper.addUnmodifiedContent();
+        for (int i = shadows.size() - 1; i >= 0; i--) {
+            shadow = shadows[i];
+            int shadowX = horizontal ? shadow->x() : shadow->y();
+            int shadowY = horizontal ? shadow->y() : -shadow->x();
+            FloatSize offset(shadowX, shadowY);
+            drawLooper.addShadow(offset, shadow->blur(), shadow->color(),
+                DrawLooper::ShadowRespectsTransforms, DrawLooper::ShadowIgnoresAlpha);
+        }
+        context->setDrawLooper(drawLooper);
+    }
 
     TextRunPaintInfo textRunPaintInfo(textRun);
     textRunPaintInfo.bounds = boxRect;
-    do {
-        IntSize extraOffset;
-        if (shadow)
-            extraOffset = roundedIntSize(InlineTextBox::applyShadowToGraphicsContext(context, shadow, boxRect, stroked, opaque, horizontal));
-        else if (!opaque)
-            context->setFillColor(fillColor, fillColorSpace);
-
-        if (startOffset <= endOffset) {
-            textRunPaintInfo.from = startOffset;
+    if (startOffset <= endOffset) {
+        textRunPaintInfo.from = startOffset;
+        textRunPaintInfo.to = endOffset;
+        if (emphasisMark.isEmpty())
+            context->drawText(font, textRunPaintInfo, textOrigin);
+        else
+            context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + IntSize(0, emphasisMarkOffset));
+    } else {
+        if (endOffset > 0) {
+            textRunPaintInfo.from = 0;
             textRunPaintInfo.to = endOffset;
             if (emphasisMark.isEmpty())
-                context->drawText(font, textRunPaintInfo, textOrigin + extraOffset);
+                context->drawText(font, textRunPaintInfo, textOrigin);
             else
-                context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + extraOffset + IntSize(0, emphasisMarkOffset));
-        } else {
-            if (endOffset > 0) {
-                textRunPaintInfo.from = 0;
-                textRunPaintInfo.to = endOffset;
-                if (emphasisMark.isEmpty())
-                    context->drawText(font, textRunPaintInfo, textOrigin + extraOffset);
-                else
-                    context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + extraOffset + IntSize(0, emphasisMarkOffset));
-            }
-            if (startOffset < truncationPoint) {
-                textRunPaintInfo.from = startOffset;
-                textRunPaintInfo.to = truncationPoint;
-                if (emphasisMark.isEmpty())
-                    context->drawText(font, textRunPaintInfo, textOrigin + extraOffset);
-                else
-                    context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + extraOffset + IntSize(0, emphasisMarkOffset));
-            }
+                context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + IntSize(0, emphasisMarkOffset));
         }
+        if (startOffset < truncationPoint) {
+            textRunPaintInfo.from = startOffset;
+            textRunPaintInfo.to = truncationPoint;
+            if (emphasisMark.isEmpty())
+                context->drawText(font, textRunPaintInfo, textOrigin);
+            else
+                context->drawEmphasisMarks(font, textRunPaintInfo, emphasisMark, textOrigin + IntSize(0, emphasisMarkOffset));
+        }
+    }
 
-        if (!shadow)
-            break;
-
-        if (shadow->next() || stroked || !opaque)
-            context->restore();
-        else
-            context->clearShadow();
-
-        shadow = shadow->next();
-    } while (shadow || stroked || !opaque);
+    if (hasShadow)
+        context->clearDrawLooper();
 }
 
 bool InlineTextBox::getEmphasisMarkPosition(RenderStyle* style, TextEmphasisPosition& emphasisPosition) const
 {
     // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
     if (style->textEmphasisMark() == TextEmphasisMarkNone)
         return false;
 
     emphasisPosition = style->textEmphasisPosition();
     if (emphasisPosition == TextEmphasisPositionUnder)
@@ skipping 679 matching lines @@
 
     do {
         if (shadow) {
             if (!shadow->next()) {
                 // The last set of lines paints normally inside the clip.
                 localOrigin.move(0, -extraOffset);
                 extraOffset = 0;
             }
             int shadowX = isHorizontal() ? shadow->x() : shadow->y();
             int shadowY = isHorizontal() ? shadow->y() : -shadow->x();
-            context->setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->blur(), shadow->color(), colorSpace);
+            context->setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow->blur(), shadow->color());
             setShadow = true;
             shadow = shadow->next();
         }
 
 #if ENABLE(CSS3_TEXT)
         // Offset between lines - always non-zero, so lines never cross each other.
         float doubleOffset = textDecorationThickness + 1.f;
 #endif // CSS3_TEXT
         context->setStrokeStyle(textDecorationStyleToStrokeStyle(decorationStyle));
         if (deco & UNDERLINE) {
@@ skipping 429 matching lines @@
 
 void InlineTextBox::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::Rendering);
     InlineBox::reportMemoryUsage(memoryObjectInfo);
     info.addMember(m_prevTextBox, "prevTextBox");
     info.addMember(m_nextTextBox, "nextTextBox");
 }
 
 } // namespace WebCore