Implementation for cc::Picture::IsCheapInRect().

skia/ext/analysis_canvas.cc

Index: skia/ext/analysis_canvas.cc
diff --git a/skia/ext/analysis_canvas.cc b/skia/ext/analysis_canvas.cc
new file mode 100644
index 0000000000000000000000000000000000000000..72b9eeb987bdc07adf74c3a2f6b0f5cdbe5b6faf
--- /dev/null
+++ b/skia/ext/analysis_canvas.cc
@@ -0,0 +1,190 @@
+// 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 "ui/gfx/rect_conversions.h"
+
+namespace {
+
+// FIXME: Arbitrary number. Requires tuning & experimentation.
+// Probably requires per-platform tuning; N10 average draw call takes
+// 25x as long as Z620.
+const int gPictureCostThreshold = 1000;
+
+}
+
+namespace skia {
+
+AnalysisDevice::AnalysisDevice(const SkBitmap& bm)
+  : INHERITED(bm)
+  , estimatedCost_(0) {
+
+}
+
+AnalysisDevice::~AnalysisDevice() {
+
+}
+
+int AnalysisDevice::getEstimatedCost() const {
+  return estimatedCost_;
+}
+
+void AnalysisDevice::clear(SkColor color) {
+    ++estimatedCost_;
+}
+
+void AnalysisDevice::drawPaint(const SkDraw&, const SkPaint& paint) {
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawPoints(const SkDraw&, SkCanvas::PointMode mode,
+                          size_t count, const SkPoint[],
+                          const SkPaint& paint) {
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawRect(const SkDraw&, const SkRect& r,
+                        const SkPaint& paint) {
+  // FIXME: if there's a pending image decode & resize, more expensive
+  if (paint.getMaskFilter()) {
+    estimatedCost_ += 300;
+  }
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawOval(const SkDraw&, const SkRect& oval,
+                        const SkPaint& paint) {
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawPath(const SkDraw&, const SkPath& path,
+                        const SkPaint& paint,
+                        const SkMatrix* prePathMatrix ,
+                        bool pathIsMutable ) {
+  // On Z620, every antialiased path costs us about 300us.
+  // We've only seen this in practice on filled paths, but
+  // we expect it to apply to all path stroking modes.
+  if (paint.getMaskFilter()) {
+    estimatedCost_ += 300;
+  }
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawBitmap(const SkDraw&, const SkBitmap& bitmap,
+                          const SkIRect* srcRectOrNull,
+                          const SkMatrix& matrix, const SkPaint& paint)
+                          {
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawSprite(const SkDraw&, const SkBitmap& bitmap,
+                          int x, int y, const SkPaint& paint) {
+  ++estimatedCost_;
+}
+
+void AnalysisDevice::drawBitmapRect(const SkDraw&, const SkBitmap&,
+                              const SkRect* srcOrNull, const SkRect& dst,
+                              const SkPaint& paint) {
+  ++estimatedCost_;
+}
+
+
+void AnalysisDevice::drawText(const SkDraw&, const void* text, size_t len,
+                        SkScalar x, SkScalar y, const SkPaint& paint)
+                        {
+  ++estimatedCost_;
+}
+
+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_;
+}
+
+void AnalysisDevice::drawTextOnPath(const SkDraw&, const void* text, size_t len,
+                              const SkPath& path, const SkMatrix* matrix,
+                              const SkPaint& paint) {
+  ++estimatedCost_;
+}
+
+#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_;
+}
+#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_;
+}
+
+void AnalysisDevice::drawDevice(const SkDraw&, SkDevice*, int x, int y,
+                          const SkPaint&) {
+  ++estimatedCost_;
+}
+
+
+
+
+AnalysisCanvas::AnalysisCanvas(AnalysisDevice* device)
+  : INHERITED(device) {
+
+}
+
+AnalysisCanvas::~AnalysisCanvas() {
+}
+
+
+bool AnalysisCanvas::isCheap() const {
+  return getEstimatedCost() < gPictureCostThreshold;
+}
+
+int AnalysisCanvas::getEstimatedCost() const {
+  return (static_cast<AnalysisDevice*>(getDevice()))->getEstimatedCost();
+}
+
+
+bool AnalysisCanvas::clipRect(const SkRect& rect, SkRegion::Op op,
+                        bool doAA) {
+  return INHERITED::clipRect(rect, op, doAA);
+}
+
+bool AnalysisCanvas::clipPath(const SkPath& path, SkRegion::Op op,
+                        bool doAA) {
+  return INHERITED::clipRect(path.getBounds(), op, doAA);
+}
+
+bool AnalysisCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op op,
+                         bool doAA) {
+  return INHERITED::clipRect(rrect.getBounds(), op, doAA);
+}
+
+int AnalysisCanvas::saveLayer(const SkRect* bounds, const SkPaint*, 
+                              SkCanvas::SaveFlags flags) {
+  // Actually saving a layer here could cause a new bitmap to be created
+  // and real rendering to occur.
+  int count = SkCanvas::save(flags);
+  if (bounds) {
+    INHERITED::clipRectBounds(bounds, flags, NULL);
+  }
+  return count;
+}
+
+}  // namespace skia
+
+