Track the region where text is painted.

Source/core/platform/graphics/chromium/FontChromiumWin.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Computer, Inc.
  * Copyright (c) 2006, 2007, 2008, 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:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 44 matching lines @@
 bool Font::canExpandAroundIdeographsInComplexText()
 {
     return false;
 }
 
 void Font::drawGlyphs(GraphicsContext* graphicsContext,
                       const SimpleFontData* font,
                       const GlyphBuffer& glyphBuffer,
                       int from,
                       int numGlyphs,
-                      const FloatPoint& point) const
+                      const FloatPoint& point,
+                      const FloatRect& textRect) const
 {
     SkColor color = graphicsContext->effectiveFillColor();
     unsigned char alpha = SkColorGetA(color);
     // Skip 100% transparent text; no need to draw anything.
     if (!alpha && graphicsContext->strokeStyleSkia() == NoStroke && !graphicsContext->hasShadow())
         return;
 
     // We draw the glyphs in chunks to avoid having to do a heap allocation for
     // the arrays of characters and advances.
     const int kMaxBufferLength = 256;
     Vector<int, kMaxBufferLength> advances;
     int glyphIndex = 0;  // The starting glyph of the current chunk.
 
     float horizontalOffset = point.x(); // The floating point offset of the left side of the current glyph.
+
 #if ENABLE(OPENTYPE_VERTICAL)
     const OpenTypeVerticalData* verticalData = font->verticalData();
     if (verticalData) {
         Vector<FloatPoint, kMaxBufferLength> translations;
         Vector<GOFFSET, kMaxBufferLength> offsets;
 
         // Skia doesn't have matrix for glyph coordinate space, so we rotate back the CTM.
         AffineTransform savedMatrix = graphicsContext->getCTM();
         graphicsContext->concatCTM(AffineTransform(0, -1, 1, 0, point.x(), point.y()));
         graphicsContext->concatCTM(AffineTransform(1, 0, 0, 1, -point.x(), -point.y()));
@@ skipping 13 matching lines @@
             offsets.resize(curLen);
             float currentWidth = 0;
             for (int i = 0; i < curLen; ++i, ++glyphIndex) {
                 offsets[i].du = lroundf(translations[i].x());
                 offsets[i].dv = -lroundf(currentWidth - translations[i].y());
                 currentWidth += glyphBuffer.advanceAt(from + glyphIndex);
             }
             SkPoint origin;
             origin.set(verticalOriginX, SkFloatToScalar(point.y() + horizontalOffset - point.x()));
             horizontalOffset += currentWidth;
-            paintSkiaText(graphicsContext, font->platformData(), curLen, &glyphs[0], &advances[0], &offsets[0], &origin);
+            paintSkiaText(graphicsContext, font->platformData(), curLen, &glyphs[0], &advances[0], &offsets[0], origin, SkRect(textRect));
         }
 
         graphicsContext->setCTM(savedMatrix);
         return;
     }
 #endif
 
     // In order to round all offsets to the correct pixel boundary, this code keeps track of the absolute position
     // of each glyph in floating point units and rounds to integer advances at the last possible moment.
 
@@ skipping 20 matching lines @@
             // seems to crash if kMaxNegativeRun is set to somewhere around
             // -32830, so we give ourselves a little breathing room.
             const int maxNegativeRun = -32768;
             const int maxPositiveRun =  32768;
             if ((currentWidth + advances[i] < maxNegativeRun) || (currentWidth + advances[i] > maxPositiveRun)) 
                 advances[i] = 0;
         }
 
         SkPoint origin = point;
         origin.fX += SkFloatToScalar(horizontalOffset - point.x() - currentWidth);
-        paintSkiaText(graphicsContext, font->platformData(), curLen, &glyphs[0], &advances[0], 0, &origin);
+        paintSkiaText(graphicsContext, font->platformData(), curLen, &glyphs[0], &advances[0], 0, origin, SkRect(textRect));
     }
 }
 
 FloatRect Font::selectionRectForComplexText(const TextRun& run,
                                             const FloatPoint& point,
                                             int h,
                                             int from,
                                             int to) const
 {
     UniscribeHelperTextRun state(run, *this);
     float left = static_cast<float>(point.x() + state.characterToX(from));
     float right = static_cast<float>(point.x() + state.characterToX(to));
 
     // If the text is RTL, left will actually be after right.
     if (left < right)
         return FloatRect(left, point.y(),
                        right - left, static_cast<float>(h));
 
     return FloatRect(right, point.y(),
                      left - right, static_cast<float>(h));
 }
 
 void Font::drawComplexText(GraphicsContext* graphicsContext,
-                           const TextRun& run,
-                           const FloatPoint& point,
-                           int from,
-                           int to) const
+                           const TextRunPaintInfo& runInfo,
+                           const FloatPoint& point) const
 {
-    UniscribeHelperTextRun state(run, *this);
+    UniscribeHelperTextRun state(runInfo.run, *this);
 
     SkColor color = graphicsContext->effectiveFillColor();
     unsigned char alpha = SkColorGetA(color);
     // Skip 100% transparent text; no need to draw anything.
     if (!alpha && graphicsContext->strokeStyleSkia() == NoStroke)
         return;
 
     HDC hdc = 0;
     // Uniscribe counts the coordinates from the upper left, while WebKit uses
     // the baseline, so we have to subtract off the ascent.
-    state.draw(graphicsContext, hdc, lroundf(point.x()), lroundf(point.y() - fontMetrics().ascent()), from, to);
+    state.draw(graphicsContext, hdc, lroundf(point.x()), lroundf(point.y() - fontMetrics().ascent()), runInfo.bounds, runInfo.from, runInfo.to);
 }
 
-void Font::drawEmphasisMarksForComplexText(GraphicsContext* /* context */, const TextRun& /* run */, const AtomicString& /* mark */, const FloatPoint& /* point */, int /* from */, int /* to */) const
+void Font::drawEmphasisMarksForComplexText(GraphicsContext* /* context */, const TextRunPaintInfo& /* runInfo */, const AtomicString& /* mark */, const FloatPoint& /* point */) const
 {
     notImplemented();
 }
 
 float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* /* fallbackFonts */, GlyphOverflow* /* glyphOverflow */) const
 {
     UniscribeHelperTextRun state(run, *this);
     return static_cast<float>(state.width());
 }
 
@@ skipping 10 matching lines @@
     int charIndex = state.xToCharacter(x);
 
     // XToCharacter will return -1 if the position is before the first
     // character (we get called like this sometimes).
     if (charIndex < 0)
         charIndex = 0;
     return charIndex;
 }
 
 } // namespace WebCore