Smart layer invalidation for LCD text.

skia/ext/analysis_canvas.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/trace_event.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkDraw.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkShader.h"
@@ skipping 78 matching lines @@
 } // namespace
 
 namespace skia {
 
 AnalysisDevice::AnalysisDevice(const SkBitmap& bm)
   : INHERITED(bm)
   , estimatedCost_(0)
   , isForcedNotSolid_(false)
   , isForcedNotTransparent_(false)
   , isSolidColor_(false)
-  , isTransparent_(false) {
-
+  , isTransparent_(false)
+  , hasText_(false) {
 }
 
 AnalysisDevice::~AnalysisDevice() {
 
 }
 
 int AnalysisDevice::getEstimatedCost() const {
   return estimatedCost_;
 }
 
 bool AnalysisDevice::getColorIfSolid(SkColor* color) const {
   if (isSolidColor_)
     *color = color_;
   return isSolidColor_;
 }
 
 bool AnalysisDevice::isTransparent() const {
   return isTransparent_;
 }
 
+bool AnalysisDevice::hasText() const {
+  return hasText_;
+}
+
 void AnalysisDevice::setForceNotSolid(bool flag) {
   isForcedNotSolid_ = flag;
   if (isForcedNotSolid_)
     isSolidColor_ = false;
 }
 
 void AnalysisDevice::setForceNotTransparent(bool flag) {
   isForcedNotTransparent_ = flag;
   if (isForcedNotTransparent_)
     isTransparent_ = false;
@@ skipping 46 matching lines @@
 }
 
 void AnalysisDevice::clear(SkColor color) {
   // FIXME: cost here should be simple rect of device size
   estimatedCost_ += kUnknownExpensiveCost;
 
   isTransparent_ = (!isForcedNotTransparent_ && SkColorGetA(color) == 0);
 
   if (!isForcedNotSolid_ && SkColorGetA(color) == 255) {
     isSolidColor_ = true;
     color_ = color;

[enne (OOO), 2013/04/05 21:39:36]

Do you need to set hasText_ here?  Can you add a test for this?

Also, the same thing anywhere else we set isSolidColor = true.

[alokp, 2013/04/05 22:50:11]

Good catch. Done. Added Tests.

   }
   else {
     isSolidColor_ = false;
   }
 }
 
 void AnalysisDevice::drawPaint(const SkDraw&, const SkPaint& paint) {
   estimatedCost_ += kUnknownExpensiveCost;
   if (hasBitmap(paint)) {
     estimatedCost_ += kUnknownBitmapCost;
@@ skipping 141 matching lines @@
 
 void AnalysisDevice::drawText(const SkDraw&, const void* text, size_t len,
                         SkScalar x, SkScalar y, const SkPaint& paint) {
   estimatedCost_ += 1 + len / kSimpleTextCharPerUS;
   if (hasBitmap(paint)) {
     estimatedCost_ += kUnknownBitmapCost;
     addBitmapFromPaint(paint);
   }
   isSolidColor_ = false;
   isTransparent_ = false;
+  hasText_ = true;
 }
 
 void AnalysisDevice::drawPosText(const SkDraw& draw, const void* text,
                            size_t len,
                            const SkScalar pos[], SkScalar constY,
                            int scalarsPerPos, const SkPaint& paint) {
   // FIXME: On Z620, every glyph cache miss costs us about 10us.
   // We don't have a good mechanism for predicting glyph cache misses.
   estimatedCost_ += 1 + len / kSimpleTextCharPerUS;
   if (hasBitmap(paint)) {
     estimatedCost_ += kUnknownBitmapCost;
     addBitmapFromPaint(paint);
   }
   isSolidColor_ = false;
   isTransparent_ = false;
+  hasText_ = true;
 }
 
 void AnalysisDevice::drawTextOnPath(const SkDraw&, const void* text,
                               size_t len,
                               const SkPath& path, const SkMatrix* matrix,
                               const SkPaint& paint) {
   estimatedCost_ += 1 + len / kSimpleTextCharPerUS;
   if (hasBitmap(paint)) {
     estimatedCost_ += kUnknownBitmapCost;
     addBitmapFromPaint(paint);
   }
   isSolidColor_ = false;
   isTransparent_ = false;
+  hasText_ = true;
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 void AnalysisDevice::drawPosTextOnPath(const SkDraw& draw, const void* text,
                                  size_t len,
                                  const SkPoint pos[], const SkPaint& paint,
                                  const SkPath& path, const SkMatrix* matrix) {
   estimatedCost_ += 1 + len / kSimpleTextCharPerUS;
   if (hasBitmap(paint)) {
     estimatedCost_ += kUnknownBitmapCost;
     addBitmapFromPaint(paint);
   }
   isSolidColor_ = false;
   isTransparent_ = false;
+  hasText_ = true;
 }
 #endif
 
 void AnalysisDevice::drawVertices(const SkDraw&, SkCanvas::VertexMode,
                             int vertexCount,
                             const SkPoint verts[], const SkPoint texs[],
                             const SkColor colors[], SkXfermode* xmode,
                             const uint16_t indices[], int indexCount,
                             const SkPaint& paint) {
   estimatedCost_ += kUnknownExpensiveCost;
@@ skipping 33 matching lines @@
 }
 
 bool AnalysisCanvas::getColorIfSolid(SkColor* color) const {
   return (static_cast<AnalysisDevice*>(getDevice()))->getColorIfSolid(color);
 }
 
 bool AnalysisCanvas::isTransparent() const {
   return (static_cast<AnalysisDevice*>(getDevice()))->isTransparent();
 }
 
+bool AnalysisCanvas::hasText() const {
+  return (static_cast<AnalysisDevice*>(getDevice()))->hasText();
+}
+
 int AnalysisCanvas::getEstimatedCost() const {
   return (static_cast<AnalysisDevice*>(getDevice()))->getEstimatedCost();
 }
 
 void AnalysisCanvas::consumeLazyPixelRefs(LazyPixelRefList* pixelRefs) {
   static_cast<AnalysisDevice*>(getDevice())->consumeLazyPixelRefs(pixelRefs);
 }
 
 bool AnalysisCanvas::clipRect(const SkRect& rect, SkRegion::Op op,
                         bool doAA) {
@@ skipping 90 matching lines @@
     if (savedStackSize_ < forceNotTransparentStackLevel_) {
       (static_cast<AnalysisDevice*>(getDevice()))->setForceNotTransparent(false);
       forceNotTransparentStackLevel_ = kNoLayer;
     }
   }
 }
 
 }  // namespace skia