use ClipOp instead of SkRegion for clipping

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 304 matching lines @@
                                  int count,
                                  DrawBitmapProc proc) {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(1000, 1000);
     for (int i = 0; i < count; ++i) {
         analytic[i].rewind();
         canvas->save();
         SkRect clipRect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY,
                                            SkIntToScalar(bm[i].width()),
                                            SkIntToScalar(bm[i].height()));
-        canvas->clipRect(clipRect, SkRegion::kIntersect_Op);
+        canvas->clipRect(clipRect);
         proc(canvas, bm[i], bm[count+i], pos[i], &analytic[i]);
         canvas->restore();
     }
     return recorder.endRecording();
 }
 
 static void rand_rect(SkRect* rect, SkRandom& rand, SkScalar W, SkScalar H) {
     rect->fLeft   = rand.nextRangeScalar(-W, 2*W);
     rect->fTop    = rand.nextRangeScalar(-H, 2*H);
     rect->fRight  = rect->fLeft + rand.nextRangeScalar(0, W);
@@ skipping 877 matching lines @@
         recorder->partialReplay(canvas);
 
         return recorder2.endRecording();
     }
 };
 
 static void create_imbalance(SkCanvas* canvas) {
     SkRect clipRect = SkRect::MakeWH(2, 2);
     SkRect drawRect = SkRect::MakeWH(10, 10);
     canvas->save();
-        canvas->clipRect(clipRect, SkRegion::kReplace_Op);
+        canvas->legacyClipRect(clipRect, SkRegion::kReplace_Op);
         canvas->translate(1.0f, 1.0f);
         SkPaint p;
         p.setColor(SK_ColorGREEN);
         canvas->drawRect(drawRect, p);
     // no restore
 }
 
 // This tests that replaying a potentially unbalanced picture into a canvas
 // doesn't affect the canvas' save count or matrix/clip state.
 static void check_balance(skiatest::Reporter* reporter, SkPicture* picture) {
@@ skipping 290 matching lines @@
     SkPath path;
     path.addOval(rect2);
     SkPath path2;
     path2.addOval(rect3);
     SkIRect clipBounds;
     SkPictureRecorder recorder;
 
     // Testing conservative-raster-clip that is enabled by PictureRecord
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(invPath, SkRegion::kIntersect_Op);
+        canvas->clipPath(invPath);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kIntersect_Op);
-        canvas->clipPath(invPath, SkRegion::kIntersect_Op);
+        canvas->clipPath(path);
+        canvas->clipPath(invPath);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kIntersect_Op);
-        canvas->clipPath(invPath, SkRegion::kUnion_Op);
+        canvas->clipPath(path);
+        canvas->legacyClipPath(invPath, SkRegion::kUnion_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kDifference_Op);
+        canvas->clipPath(path, kDifference_SkClipOp);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kReverseDifference_Op);
+        canvas->legacyClipPath(path, SkRegion::kReverseDifference_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         // True clip is actually empty in this case, but the best
         // determination we can make using only bounds as input is that the
         // clip is included in the bounds of 'path'.
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
-        canvas->clipPath(path, SkRegion::kIntersect_Op);
-        canvas->clipPath(path2, SkRegion::kXOR_Op);
+        canvas->clipPath(path);
+        canvas->legacyClipPath(path2, SkRegion::kXOR_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 6 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 6 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
 }
 
 /**
@@ skipping 37 matching lines @@
 private:
     unsigned fClipCount;
 
     typedef SkCanvas INHERITED;
 };
 
 static void test_clip_expansion(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(10, 10);
 
-    canvas->clipRect(SkRect::MakeEmpty(), SkRegion::kReplace_Op);
+    canvas->legacyClipRect(SkRect::MakeEmpty(), SkRegion::kReplace_Op);
     // The following expanding clip should not be skipped.
-    canvas->clipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkRegion::kUnion_Op);
+    canvas->legacyClipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkRegion::kUnion_Op);
     // Draw something so the optimizer doesn't just fold the world.
     SkPaint p;
     p.setColor(SK_ColorBLUE);
     canvas->drawPaint(p);
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     ClipCountingCanvas testCanvas(10, 10);
     picture->playback(&testCanvas);
 
     // Both clips should be present on playback.
@@ skipping 258 matching lines @@
 
     // The picture shares the immutable pixels but copies the mutable ones.
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, !immut.pixelRef()->unique());
 
     // When the picture goes away, it's just our bitmaps holding the refs.
     pic.reset(NULL);
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, immut.pixelRef()->unique());
 }