reverting r3257 because of gm failure.

git-svn-id: http://skia.googlecode.com/svn/trunk@3258 2bbb7eff-a529-9590-31e7-b0007b416f81

diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index 9445f17..058979d 100644 (file)
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -283,7 +283,7 @@ public:
     /** Returns the number of matrix/clip states on the SkCanvas' private stack.
         This will equal # save() calls - # restore() calls.
     */
-    int getSaveCount() const;
+    virtual int getSaveCount() const;
 
     /** Efficient way to pop any calls to save() that happened after the save
         count reached saveCount. It is an error for saveCount to be less than
@@ -850,7 +850,7 @@ public:
         This does not account for the translate in any of the devices.
         @return The current matrix on the canvas.
     */
-    const SkMatrix& getTotalMatrix() const;
+    virtual const SkMatrix& getTotalMatrix() const;
 
     enum ClipType {
         kEmpty_ClipType = 0,
@@ -936,11 +936,6 @@ protected:
     virtual void commonDrawBitmap(const SkBitmap&, const SkIRect*,
                                   const SkMatrix&, const SkPaint& paint);
 
-    // Clip rectangle bounds. Used internally by saveLayer.
-    // returns false if the entire rectangle is clipped out
-    bool clipRectBounds(const SkRect* bounds, SaveFlags flags,
-                         SkIRect* intersection);
-
 private:
     class MCRec;
 

diff --git a/include/utils/SkDeferredCanvas.h b/include/utils/SkDeferredCanvas.h
index 87797ac..e06ea81 100644 (file)
--- a/include/utils/SkDeferredCanvas.h
+++ b/include/utils/SkDeferredCanvas.h
@@ -80,13 +80,14 @@ public:
     virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,
                           SaveFlags flags) SK_OVERRIDE;
     virtual void restore() SK_OVERRIDE;
-    virtual bool isDrawingToLayer() const SK_OVERRIDE;
+    virtual int getSaveCount() const SK_OVERRIDE;
     virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
     virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
     virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
     virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
     virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
     virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
+    virtual const SkMatrix& getTotalMatrix() const SK_OVERRIDE;
     virtual bool clipRect(const SkRect& rect, SkRegion::Op op,
                           bool doAntiAlias) SK_OVERRIDE;
     virtual bool clipPath(const SkPath& path, SkRegion::Op op,

diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 78751de..6e061c2 100644 (file)
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -707,12 +707,19 @@ static bool bounds_affects_clip(SkCanvas::SaveFlags flags) {
     return (flags & SkCanvas::kClipToLayer_SaveFlag) != 0;
 }
 
-bool SkCanvas::clipRectBounds(const SkRect* bounds, SaveFlags flags,
-                               SkIRect* intersection) {
+int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
+                        SaveFlags flags) {
+    // do this before we create the layer. We don't call the public save() since
+    // that would invoke a possibly overridden virtual
+    int count = this->internalSave(flags);
+
+    fDeviceCMDirty = true;
+
     SkIRect clipBounds;
     if (!this->getClipDeviceBounds(&clipBounds)) {
-        return false;
+        return count;
     }
+
     SkIRect ir;
     if (NULL != bounds) {
         SkRect r;
@@ -724,36 +731,16 @@ bool SkCanvas::clipRectBounds(const SkRect* bounds, SaveFlags flags,
             if (bounds_affects_clip(flags)) {
                 fMCRec->fRasterClip->setEmpty();
             }
-            return false;
+            return count;
         }
     } else {    // no user bounds, so just use the clip
         ir = clipBounds;
     }
 
     fClipStack.clipDevRect(ir, SkRegion::kIntersect_Op);
-
     // early exit if the clip is now empty
     if (bounds_affects_clip(flags) &&
         !fMCRec->fRasterClip->op(ir, SkRegion::kIntersect_Op)) {
-        return false;
-    }
-
-    if (intersection) {
-        *intersection = ir;
-    }
-    return true;
-}
-
-int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
-                        SaveFlags flags) {
-    // do this before we create the layer. We don't call the public save() since
-    // that would invoke a possibly overridden virtual
-    int count = this->internalSave(flags);
-
-    fDeviceCMDirty = true;
-
-    SkIRect ir;
-    if (!this->clipRectBounds(bounds, flags, &ir)) {
         return count;
     }
 

diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index ba49b72..c56c104 100644 (file)
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -62,9 +62,7 @@ int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
         clip starts out the size of the picture, which is often much larger
         than the size of the actual device we'll use during playback).
      */
-    int count = this->INHERITED::save(flags);
-    this->clipRectBounds(bounds, flags, NULL);
-    return count;
+    return this->INHERITED::save(flags);
 }
 
 bool SkPictureRecord::isDrawingToLayer() const {

diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index 1254392..00a26b9 100644 (file)
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -101,6 +101,7 @@ void SkDeferredCanvas::init()
 void SkDeferredCanvas::validate() const
 {
     SkASSERT(getDevice());
+    SkASSERT(INHERITED::getTotalMatrix().isIdentity());
 }
 
 SkCanvas* SkDeferredCanvas::drawingCanvas() const
@@ -215,87 +216,78 @@ bool SkDeferredCanvas::isFullFrame(const SkRect* rect,
 
 int SkDeferredCanvas::save(SaveFlags flags)
 {
-    drawingCanvas()->save(flags);
-    return this->INHERITED::save(flags);
+    return drawingCanvas()->save(flags);
 }
 
 int SkDeferredCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
                           SaveFlags flags)
 {
-    drawingCanvas()->saveLayer(bounds, paint, flags);
-    int count = this->INHERITED::save(flags);
-    this->clipRectBounds(bounds, flags, NULL);
-    return count;
+    return drawingCanvas()->saveLayer(bounds, paint, flags);
 }
 
 void SkDeferredCanvas::restore()
 {
     drawingCanvas()->restore();
-    this->INHERITED::restore();
 }
 
-bool SkDeferredCanvas::isDrawingToLayer() const
+int SkDeferredCanvas::getSaveCount() const
 {
-    return drawingCanvas()->isDrawingToLayer();
+    return drawingCanvas()->getSaveCount();
 }
 
 bool SkDeferredCanvas::translate(SkScalar dx, SkScalar dy)
 {
-    drawingCanvas()->translate(dx, dy);
-    return this->INHERITED::translate(dx, dy);
+    return drawingCanvas()->translate(dx, dy);
 }
 
 bool SkDeferredCanvas::scale(SkScalar sx, SkScalar sy)
 {
-    drawingCanvas()->scale(sx, sy);
-    return this->INHERITED::scale(sx, sy);
+    return drawingCanvas()->scale(sx, sy);
 }
 
 bool SkDeferredCanvas::rotate(SkScalar degrees)
 {
-    drawingCanvas()->rotate(degrees);
-    return this->INHERITED::rotate(degrees);
+    return drawingCanvas()->rotate(degrees);
 }
 
 bool SkDeferredCanvas::skew(SkScalar sx, SkScalar sy)
 {
-    drawingCanvas()->skew(sx, sy);
-    return this->INHERITED::skew(sx, sy);
+    return drawingCanvas()->skew(sx, sy);
 }
 
 bool SkDeferredCanvas::concat(const SkMatrix& matrix)
 {
-    drawingCanvas()->concat(matrix);
-    return this->INHERITED::concat(matrix);
+    return drawingCanvas()->concat(matrix);
 }
 
 void SkDeferredCanvas::setMatrix(const SkMatrix& matrix)
 {
     drawingCanvas()->setMatrix(matrix);
-    this->INHERITED::setMatrix(matrix);
+}
+
+const SkMatrix& SkDeferredCanvas::getTotalMatrix() const 
+{
+    return drawingCanvas()->getTotalMatrix();
 }
 
 bool SkDeferredCanvas::clipRect(const SkRect& rect,
                                 SkRegion::Op op,
                                 bool doAntiAlias)
 {
-    drawingCanvas()->clipRect(rect, op, doAntiAlias);
-    return this->INHERITED::clipRect(rect, op, doAntiAlias);
+    return drawingCanvas()->clipRect(rect, op, doAntiAlias);
 }
 
 bool SkDeferredCanvas::clipPath(const SkPath& path,
                                 SkRegion::Op op,
                                 bool doAntiAlias)
 {
-    drawingCanvas()->clipPath(path, op, doAntiAlias);
-    return this->INHERITED::clipPath(path, op, doAntiAlias);
+    return drawingCanvas()->clipPath(path, op, doAntiAlias);
 }
 
 bool SkDeferredCanvas::clipRegion(const SkRegion& deviceRgn,
                                   SkRegion::Op op)
 {
-    drawingCanvas()->clipRegion(deviceRgn, op);
-    return this->INHERITED::clipRegion(deviceRgn, op);
+    return drawingCanvas()->clipRegion(deviceRgn, op);
 }
 
 void SkDeferredCanvas::clear(SkColor color)
@@ -462,14 +454,14 @@ void SkDeferredCanvas::drawVertices(VertexMode vmode, int vertexCount,
 
 SkBounder* SkDeferredCanvas::setBounder(SkBounder* bounder)
 {
-    drawingCanvas()->setBounder(bounder);
-    return INHERITED::setBounder(bounder);
+    INHERITED::setBounder(bounder); // So non-virtual getBounder works
+    return drawingCanvas()->setBounder(bounder);
 }
 
 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter)
 {
-    drawingCanvas()->setDrawFilter(filter); 
-    return INHERITED::setDrawFilter(filter); // So non-virtual getDrawFilter works
+    INHERITED::setDrawFilter(filter); // So non-virtual getDrawFilter works
+    return drawingCanvas()->setDrawFilter(filter); 
 }
 
 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
@@ -490,7 +482,8 @@ SkDeferredCanvas::DeferredDevice::DeferredDevice(
     fImmediateDevice = immediateDevice; // ref counted via fImmediateCanvas
     fImmediateCanvas = SkNEW_ARGS(SkCanvas, (fImmediateDevice));
     fRecordingCanvas = fPicture.beginRecording(fImmediateDevice->width(),
-        fImmediateDevice->height(), 0);
+        fImmediateDevice->height(),
+        SkPicture::kUsePathBoundsForClip_RecordingFlag);
 }
 
 SkDeferredCanvas::DeferredDevice::~DeferredDevice()
@@ -525,7 +518,8 @@ void SkDeferredCanvas::DeferredDevice::contentsCleared()
             // old one, hence purging deferred draw ops.
             fRecordingCanvas = fPicture.beginRecording(
                 fImmediateDevice->width(),
-                fImmediateDevice->height(), 0);
+                fImmediateDevice->height(),
+                SkPicture::kUsePathBoundsForClip_RecordingFlag);
 
             // Restore pre-purge state
             if (!clipRegion.isEmpty()) {
@@ -554,7 +548,8 @@ void SkDeferredCanvas::DeferredDevice::flushPending()
     }
     fPicture.draw(fImmediateCanvas);
     fRecordingCanvas = fPicture.beginRecording(fImmediateDevice->width(), 
-        fImmediateDevice->height(), 0);
+        fImmediateDevice->height(),
+        SkPicture::kUsePathBoundsForClip_RecordingFlag);
 }
 
 void SkDeferredCanvas::DeferredDevice::flush()

diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 0c4683e..54b728b 100644 (file)
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -224,25 +224,27 @@ TEST_STEP(NAME, NAME##TestStep )
 // Basic test steps for most virtual methods in SkCanvas that draw or affect 
 // the state of the canvas.
 
-SIMPLE_TEST_STEP(SaveMatrix, save(SkCanvas::kMatrix_SaveFlag));
-SIMPLE_TEST_STEP(SaveClip, save(SkCanvas::kClip_SaveFlag));
-SIMPLE_TEST_STEP(SaveMatrixClip, save(SkCanvas::kMatrixClip_SaveFlag));
-SIMPLE_TEST_STEP(SaveLayer, saveLayer(NULL, NULL));
-SIMPLE_TEST_STEP(BoundedSaveLayer, saveLayer(&kTestRect, NULL));
-SIMPLE_TEST_STEP(PaintSaveLayer, saveLayer(NULL, &kTestPaint));
-SIMPLE_TEST_STEP_WITH_ASSERT(Translate,
-    translate(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Scale,
-    scale(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Rotate, rotate(SkIntToScalar(1)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Skew,
-    skew(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Concat, concat(kTestMatrix));
-SIMPLE_TEST_STEP(SetMatrix, setMatrix(kTestMatrix));
-SIMPLE_TEST_STEP_WITH_ASSERT(ClipRect, clipRect(kTestRect));
-SIMPLE_TEST_STEP_WITH_ASSERT(ClipPath, clipPath(kTestPath));
-SIMPLE_TEST_STEP_WITH_ASSERT(ClipRegion,
-    clipRegion(kTestRegion, SkRegion::kReplace_Op));
+// The following test steps are commented-out because they currently fail
+// Issue: http://code.google.com/p/skia/issues/detail?id=506
+//SIMPLE_TEST_STEP(SaveMatrix, save(SkCanvas::kMatrix_SaveFlag));
+//SIMPLE_TEST_STEP(SaveClip, save(SkCanvas::kClip_SaveFlag));
+//SIMPLE_TEST_STEP(SaveMatrixClip, save(SkCanvas::kMatrixClip_SaveFlag));
+//SIMPLE_TEST_STEP(SaveLayer, saveLayer(NULL, NULL));
+//SIMPLE_TEST_STEP(BoundedSaveLayer, saveLayer(&kTestRect, NULL));
+//SIMPLE_TEST_STEP(PaintSaveLayer, saveLayer(NULL, &kTestPaint));
+//SIMPLE_TEST_STEP_WITH_ASSERT(Translate,
+//    translate(SkIntToScalar(1), SkIntToScalar(2)));
+//SIMPLE_TEST_STEP_WITH_ASSERT(Scale,
+//    scale(SkIntToScalar(1), SkIntToScalar(2)));
+//SIMPLE_TEST_STEP_WITH_ASSERT(Rotate, rotate(SkIntToScalar(1)));
+//SIMPLE_TEST_STEP_WITH_ASSERT(Skew,
+//    skew(SkIntToScalar(1), SkIntToScalar(2)));
+//SIMPLE_TEST_STEP_WITH_ASSERT(Concat, concat(kTestMatrix));
+//SIMPLE_TEST_STEP(SetMatrix, setMatrix(kTestMatrix));
+//SIMPLE_TEST_STEP_WITH_ASSERT(ClipRect, clipRect(kTestRect));
+//SIMPLE_TEST_STEP_WITH_ASSERT(ClipPath, clipPath(kTestPath));
+//SIMPLE_TEST_STEP_WITH_ASSERT(ClipRegion,
+//    clipRegion(kTestRegion, SkRegion::kReplace_Op));
 SIMPLE_TEST_STEP(Clear, clear(kTestColor));
 SIMPLE_TEST_STEP(DrawPaint, drawPaint(kTestPaint));
 SIMPLE_TEST_STEP(DrawPointsPoints, drawPoints(SkCanvas::kPoints_PointMode,
@@ -339,6 +341,9 @@ static void SaveRestoreTestStep(SkCanvas* canvas,
 }
 TEST_STEP(SaveRestore, SaveRestoreTestStep);
 
+// The following test step is commented-out because it currently fails
+// Issue: http://code.google.com/p/skia/issues/detail?id=506
+/*
 static void DrawLayerTestStep(SkCanvas* canvas, 
                               skiatest::Reporter* reporter,
                               CanvasTestStep* testStep) {
@@ -371,6 +376,7 @@ static void DrawLayerTestStep(SkCanvas* canvas,
         testStep->assertMessage());
 }
 TEST_STEP(DrawLayer, DrawLayerTestStep);
+*/
 
 static void AssertCanvasStatesEqual(skiatest::Reporter* reporter,
                                     const SkCanvas* canvas1,