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 43 matching lines @@
   DCHECK(pixelRefs->empty());
   lazyPixelRefs_.swap(*pixelRefs);
   existingPixelRefIDs_.clear();
 }
 
 void AnalysisDevice::clear(SkColor color) {
   // FIXME: cost here should be simple rect of device size
   estimatedCost_ += kUnknownExpensiveCost;
 
   isTransparent_ = (!isForcedNotTransparent_ && SkColorGetA(color) == 0);
+  hasText_ = false;
 
   if (!isForcedNotSolid_ && SkColorGetA(color) == 255) {
     isSolidColor_ = true;
     color_ = color;
   }
   else {
     isSolidColor_ = false;
   }
 }
 
@@ skipping 45 matching lines @@
   // - Transfer mode is clear (0 color, 0 alpha)
   //
   // If the paint alpha is not 0, or if the transfrer mode is
   // not src, then this canvas will not be transparent.
   //
   // In all other cases, we keep the current transparent value
   if (doesCoverCanvas &&
       !isForcedNotTransparent_ &&
       xferMode == SkXfermode::kClear_Mode) {
     isTransparent_ = true;
+    hasText_ = false;
   }
   else if (paint.getAlpha() != 0 ||
            xferMode != SkXfermode::kSrc_Mode) {
     isTransparent_ = false;
   }
 
   // This bitmap is solid if and only if the following holds.
   // Note that this might be overly conservative:
   // - We're not in "forced not solid" mode
   // - Paint is solid color
   // - The quad is a full tile quad
   if (!isForcedNotSolid_ &&
       isSolidColorPaint(paint) &&
       doesCoverCanvas) {
     isSolidColor_ = true;
     color_ = paint.getColor();
+    hasText_ = false;
   }
   else {
     isSolidColor_ = false;
   }
 }
 
 void AnalysisDevice::drawOval(const SkDraw&, const SkRect& oval,
                         const SkPaint& paint) {
   estimatedCost_ += kUnknownExpensiveCost;
   if (hasBitmap(paint)) {
@@ skipping 64 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