Track the region where text is painted.

Source/core/platform/graphics/skia/SkiaFontWin.cpp

 /*
  * Copyright (c) 2008, 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 30 matching lines @@
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/core/SkTemplates.h"
 
 namespace WebCore {
 
 static void skiaDrawText(GraphicsContext* context,
                          const SkPoint& point,
+                         const SkRect& textRect,
                          SkPaint* paint,
                          const WORD* glyphs,
                          const int* advances,
                          const GOFFSET* offsets,
                          int numGlyphs)
 {
     // Reserve space for 64 SkPoints on the stack. If numGlyphs is larger, the array
     // will dynamically allocate it space for numGlyph glyphs. This is used to store
     // the computed x,y locations. In the case where offsets==null, then we use it
     // to store (twice as many) SkScalars for x[]
     static const size_t kLocalGlyphMax = 64;
 
     SkScalar x = point.fX;
     SkScalar y = point.fY;
     if (offsets) {
         SkAutoSTArray<kLocalGlyphMax, SkPoint> storage(numGlyphs);
         SkPoint* pos = storage.get();
         for (int i = 0; i < numGlyphs; i++) {
             // GDI has dv go up, so we negate it
             pos[i].set(x + SkIntToScalar(offsets[i].du),
                        y + -SkIntToScalar(offsets[i].dv));
             x += SkIntToScalar(advances[i]);
         }
-        context->drawPosText(glyphs, numGlyphs * sizeof(uint16_t), pos, *paint);
+        context->drawPosText(glyphs, numGlyphs * sizeof(uint16_t), pos, textRect, *paint);
     } else {
         SkAutoSTArray<kLocalGlyphMax * 2, SkScalar> storage(numGlyphs);
         SkScalar* xpos = storage.get();
         for (int i = 0; i < numGlyphs; i++) {
             xpos[i] = x;
             x += SkIntToScalar(advances[i]);
         }
         context->drawPosTextH(glyphs, numGlyphs * sizeof(uint16_t),
-                             xpos, y, *paint);
+                             xpos, y, textRect, *paint);
     }
 }
 
 static void setupPaintForFont(SkPaint* paint, GraphicsContext* context,
                               SkTypeface* face, float size, uint32_t textFlags)
 {
     paint->setTextSize(SkFloatToScalar(size));
     paint->setTypeface(face);
 
     if (!context->couldUseLCDRenderedText()) {
@@ skipping 17 matching lines @@
     flags |= textFlags;
     paint->setFlags(flags);
 }
 
 static void paintSkiaText(GraphicsContext* context, HFONT hfont,
                           SkTypeface* face, float size, uint32_t textFlags,
                           int numGlyphs,
                           const WORD* glyphs,
                           const int* advances,
                           const GOFFSET* offsets,
-                          const SkPoint* origin)
+                          const SkPoint& origin,
+                          const SkRect& textRect)
 {
     TextDrawingModeFlags textMode = context->textDrawingModeSkia();
     // Ensure font load for printing, because PDF device needs it.
     if (context->isPrintingDevice())
         FontPlatformData::ensureFontLoaded(hfont);
 
     // Filling (if necessary). This is the common case.
     SkPaint paint;
     context->setupPaintForFilling(&paint);
     paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
     setupPaintForFont(&paint, context, face, size, textFlags);
 
     bool didFill = false;
 
     if ((textMode & TextModeFill) && (SkColorGetA(paint.getColor()) || paint.getLooper())) {
-        skiaDrawText(context, *origin, &paint, &glyphs[0], &advances[0], &offsets[0], numGlyphs);
+        skiaDrawText(context, origin, textRect, &paint, &glyphs[0], &advances[0], &offsets[0], numGlyphs);
         didFill = true;
     }
 
     // Stroking on top (if necessary).
     if ((textMode & TextModeStroke)
         && context->strokeStyleSkia() != NoStroke
         && context->strokeThicknessSkia() > 0) {
 
         paint.reset();
         context->setupPaintForStroking(&paint, 0, 0);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
         setupPaintForFont(&paint, context, face, size, textFlags);
 
         if (didFill) {
             // If there is a shadow and we filled above, there will already be
             // a shadow. We don't want to draw it again or it will be too dark
             // and it will go on top of the fill.
             //
             // Note that this isn't strictly correct, since the stroke could be
             // very thick and the shadow wouldn't account for this. The "right"
             // thing would be to draw to a new layer and then draw that layer
             // with a shadow. But this is a lot of extra work for something
             // that isn't normally an issue.
             paint.setLooper(0);
         }
 
-        skiaDrawText(context, *origin, &paint, &glyphs[0], &advances[0], &offsets[0], numGlyphs);
+        skiaDrawText(context, origin, textRect, &paint, &glyphs[0], &advances[0], &offsets[0], numGlyphs);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 void paintSkiaText(GraphicsContext* context,
                    const FontPlatformData& data,
                    int numGlyphs,
                    const WORD* glyphs,
                    const int* advances,
                    const GOFFSET* offsets,
-                   const SkPoint* origin)
+                   const SkPoint& origin,
+                   const SkRect& textRect)
 {
     paintSkiaText(context, data.hfont(), data.typeface(), data.size(), data.paintTextFlags(),
-                  numGlyphs, glyphs, advances, offsets, origin);
+                  numGlyphs, glyphs, advances, offsets, origin, textRect);
 }
 
 void paintSkiaText(GraphicsContext* context,
                    HFONT hfont,
                    int numGlyphs,
                    const WORD* glyphs,
                    const int* advances,
                    const GOFFSET* offsets,
-                   const SkPoint* origin)
+                   const SkPoint& origin,
+                   const SkRect& textRect)
 {
     int size;
     int paintTextFlags;
     SkTypeface* face = CreateTypefaceFromHFont(hfont, &size, &paintTextFlags);
     SkAutoUnref aur(face);
 
-    paintSkiaText(context, hfont, face, size, paintTextFlags, numGlyphs, glyphs, advances, offsets, origin);
+    paintSkiaText(context, hfont, face, size, paintTextFlags, numGlyphs, glyphs, advances, offsets, origin, textRect);
 }
 
 }  // namespace WebCore