Track the region where text is painted.

Source/core/platform/graphics/skia/PlatformContextSkia.h

 /*
  * 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 168 matching lines @@
     void setAccelerated(bool accelerated) { m_accelerated = accelerated; }
 
     float deviceScaleFactor() const { return m_deviceScaleFactor; }
     void setDeviceScaleFactor(float scale) { m_deviceScaleFactor = scale; }
 
     void setTrackOpaqueRegion(bool track) { m_trackOpaqueRegion = track; }
 
     // This will be an empty region unless tracking is enabled.
     const OpaqueRegionSkia& opaqueRegion() const { return m_opaqueRegion; }
 
+    void setTrackTextRegion(bool track) { m_trackTextRegion = track; }
+    // This will be an empty region unless tracking is enabled.
+    const SkRect& textRegion() const { return m_textRegion; }
+
     // After drawing directly to the context's canvas, use this function to notify the context so
     // it can track the opaque region.
     // FIXME: this is still needed only because ImageSkia::paintSkBitmap() may need to notify for a
     //        smaller rect than the one drawn to, due to its clipping logic.
     void didDrawRect(const SkRect&, const SkPaint&, const SkBitmap* = 0);
 
     // Turn off LCD text for the paint if not supported on this context.
     void adjustTextRenderMode(SkPaint*);
     bool couldUseLCDRenderedText();
 
@@ skipping 32 matching lines @@
     bool translate(SkScalar dx, SkScalar dy);
 
     void drawBitmap(const SkBitmap&, SkScalar, SkScalar, const SkPaint* = 0);
     void drawBitmapRect(const SkBitmap&, const SkIRect*, const SkRect&, const SkPaint* = 0);
     void drawOval(const SkRect&, const SkPaint&);
     void drawPath(const SkPath&, const SkPaint&);
     void drawPoints(SkCanvas::PointMode, size_t count, const SkPoint pts[], const SkPaint&);
     void drawRect(const SkRect&, const SkPaint&);
     void drawIRect(const SkIRect&, const SkPaint&);
     void drawRRect(const SkRRect&, const SkPaint&);
-    void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint&);
+    void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkRect& textRect, const SkPaint&);
     void drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY,
-        const SkPaint&);
-    void drawTextOnPath(const void* text, size_t byteLength, const SkPath&,
+        const SkRect& textRect, const SkPaint&);
+    void drawTextOnPath(const void* text, size_t byteLength, const SkPath&, const SkRect& textRect,
         const SkMatrix*, const SkPaint&);
 
 private:
     // Used when restoring and the state has an image clip. Only shows the pixels in
     // m_canvas that are also in imageBuffer.
     // The clipping rectangle is given in absolute coordinates.
     void applyClipFromImage(const SkRect&, const SkBitmap&);
 
     // common code between setupPaintFor[Filling,Stroking]
     void setupShader(SkPaint*, Gradient*, Pattern*, SkColor) const;
 
     void realizeSave(SkCanvas::SaveFlags);
 
+    void trackTextRegion(const SkRect& textRect);
+
     // Defines drawing style.
     struct State;
 
     struct DeferredSaveState;
 
     // NULL indicates painting is disabled. Never delete this object.
     SkCanvas* m_canvas;
     const GraphicsContext* m_gc;
 
     // States stack. Enables local drawing state change with save()/restore()
     // calls.
     WTF::Vector<State> m_stateStack;
     // Pointer to the current drawing state. This is a cached value of
     // mStateStack.back().
     State* m_state;
 
     WTF::Vector<DeferredSaveState> m_saveStateStack;
 
     // Currently pending save flags.
     // FIXME: While defined as a bitmask of SkCanvas::SaveFlags, this is mostly used as a bool.
     //        It will come in handy when adding granular save() support (clip vs. matrix vs. paint).
     unsigned m_deferredSaveFlags;
 
     // Tracks the region painted opaque via the GraphicsContext.
     OpaqueRegionSkia m_opaqueRegion;
     bool m_trackOpaqueRegion;
 
+    // Tracks the region where text is painted via GraphicsContext.
+    bool m_trackTextRegion;
+    SkRect m_textRegion;
+
     bool m_printing;
     bool m_accelerated;
     bool m_drawingToImageBuffer;
     float m_deviceScaleFactor;
 };
 
 inline void PlatformContextSkia::realizeSave(SkCanvas::SaveFlags flags)
 {
     if (m_deferredSaveFlags & flags) {
         m_canvas->save((SkCanvas::SaveFlags)m_deferredSaveFlags);
@@ skipping 174 matching lines @@
 }
 
 inline void PlatformContextSkia::drawRRect(const SkRRect& rect, const SkPaint& paint)
 {
     m_canvas->drawRRect(rect, paint);
 
     if (m_trackOpaqueRegion)
         m_opaqueRegion.didDrawBounded(this, rect.getBounds(), paint);
 }
 
-inline void PlatformContextSkia::drawPosText(const void* text, size_t byteLength,
-    const SkPoint pos[], const SkPaint& paint)
+inline void PlatformContextSkia::drawPosText(const void* text,
+                                             size_t byteLength,
+                                             const SkPoint pos[],
+                                             const SkRect& textRect,
+                                             const SkPaint& paint)
 {
     m_canvas->drawPosText(text, byteLength, pos, paint);
+    trackTextRegion(textRect);

[eseidel, 2013/04/18 21:04:38]

Do we ever stop tracking?  Should this be didDrawTextInRect? or similar?

[alokp, 2013/04/18 22:22:37]

I like didDrawTextInRect. Changed.

 
     // FIXME: compute bounds for positioned text.
     if (m_trackOpaqueRegion)
         m_opaqueRegion.didDrawUnbounded(this, paint, OpaqueRegionSkia::FillOrStroke);
 }
 
-inline void PlatformContextSkia::drawPosTextH(const void* text, size_t byteLength,
-    const SkScalar xpos[], SkScalar constY, const SkPaint& paint)
+inline void PlatformContextSkia::drawPosTextH(const void* text,
+                                              size_t byteLength,
+                                              const SkScalar xpos[],
+                                              SkScalar constY,
+                                              const SkRect& textRect,
+                                              const SkPaint& paint)
 {
     m_canvas->drawPosTextH(text, byteLength, xpos, constY, paint);
+    trackTextRegion(textRect);
 
     // FIXME: compute bounds for positioned text.
     if (m_trackOpaqueRegion)
         m_opaqueRegion.didDrawUnbounded(this, paint, OpaqueRegionSkia::FillOrStroke);
 }
 
-inline void PlatformContextSkia::drawTextOnPath(const void* text, size_t byteLength,
-    const SkPath& path, const SkMatrix* matrix, const SkPaint& paint)
+inline void PlatformContextSkia::drawTextOnPath(const void* text,
+                                                size_t byteLength,
+                                                const SkPath& path,
+                                                const SkRect& textRect,
+                                                const SkMatrix* matrix,
+                                                const SkPaint& paint)
 {
     m_canvas->drawTextOnPath(text, byteLength, path, matrix, paint);
+    trackTextRegion(textRect);

[eseidel, 2013/04/18 21:04:38]

It's not clear to me that "textRect" is the right name.  If I pass the wrong
rect, what will happen?  Should this be textClipRect?  Will the rect actually
clip?

This introduces a whole new class of bugs (rect mismatches) to our text system,
but I suspect that the perf wins are definitely worth the added complexity.

[alokp, 2013/04/18 22:22:37]

It does not clip right now. The plan is to use for quick-reject and tracking
text-region for LCD text.
Yes. That is a concern. But I guess those bugs will be quite obvious - the text
will be rejected. Moreover in most cases we are reusing the text-rect computed
during layout, so mismatched rects may not be a big problem.

 
     // FIXME: compute bounds for positioned text.
     if (m_trackOpaqueRegion)
         m_opaqueRegion.didDrawUnbounded(this, paint, OpaqueRegionSkia::FillOrStroke);
 }
 
 }
 #endif // PlatformContextSkia_h