Upgrade GPUOptimize

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"
+#include "SkColorMatrixFilter.h"
 #include "SkColorPriv.h"
 #include "SkDashPathEffect.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkError.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
@@ skipping 838 matching lines @@
 
         GrContext* context = factory->get(glCtxType);
 
         if (NULL == context) {
             continue;
         }
 
         static const int kWidth = 100;
         static const int kHeight = 100;
 
+        // Create complex paint that the bounding box computation code can't
+        // optimize away
+        SkScalar blueToRedMatrix[20] = { 0 };
+        blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
+        SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
+        SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get()));
+
+        SkPaint complexPaint;
+        complexPaint.setImageFilter(filter);
+
         SkAutoTUnref<SkPicture> pict, child;
 
         {
             SkPictureRecorder recorder;
 
             SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight));
 
-            c->saveLayer(NULL, NULL);
+            c->saveLayer(NULL, &complexPaint);
             c->restore();
 
             child.reset(recorder.endRecording());
         }
 
         // create a picture with the structure:
         // 1)
         //      SaveLayer
         //      Restore
         // 2)
@@ skipping 12 matching lines @@
         // 5)
         //      SaveLayer
         //          DrawPicture with Matrix & Paint (with SaveLayer/Restore pair)
         //      Restore
         {
             SkPictureRecorder recorder;
 
             SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth),
                                                   SkIntToScalar(kHeight));
             // 1)
-            c->saveLayer(NULL, NULL); // layer #0
+            c->saveLayer(NULL, &complexPaint); // layer #0
             c->restore();
 
             // 2)
             c->saveLayer(NULL, NULL); // layer #1
                 c->translate(kWidth/2.0f, kHeight/2.0f);
                 SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2);
-                c->saveLayer(&r, NULL); // layer #2
+                c->saveLayer(&r, &complexPaint); // layer #2
                 c->restore();
             c->restore();
 
             // 3)
             {
-                SkPaint p;
-                p.setColor(SK_ColorRED);
-                c->saveLayer(NULL, &p); // layer #3
+                c->saveLayer(NULL, &complexPaint); // layer #3
                 c->restore();
             }
 
             SkPaint layerPaint;
             layerPaint.setColor(SK_ColorRED);  // Non-alpha only to avoid SaveLayerDrawRestoreNooper
             // 4)
             {
                 c->saveLayer(NULL, &layerPaint);  // layer #4
                     c->drawPicture(child);  // layer #5 inside picture
                 c->restore();
@@ skipping 44 matching lines @@
             // The parent/child layers appear in reverse order
             const GrAccelData::SaveLayerInfo& info6 = gpuData->saveLayerInfo(7);
             const GrAccelData::SaveLayerInfo& info7 = gpuData->saveLayerInfo(6);
 
             REPORTER_ASSERT(reporter, NULL == info0.fPicture);
             REPORTER_ASSERT(reporter, kWidth == info0.fBounds.width() &&
                                       kHeight == info0.fBounds.height());
             REPORTER_ASSERT(reporter, info0.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info0.fPreMat.isIdentity());
             REPORTER_ASSERT(reporter, 0 == info0.fBounds.fLeft && 0 == info0.fBounds.fTop);
-            REPORTER_ASSERT(reporter, NULL == info0.fPaint);
+            REPORTER_ASSERT(reporter, NULL != info0.fPaint);
             REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers);
 
             REPORTER_ASSERT(reporter, NULL == info1.fPicture);
             REPORTER_ASSERT(reporter, kWidth == info1.fBounds.width() &&
                                       kHeight == info1.fBounds.height());
             REPORTER_ASSERT(reporter, info1.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info1.fPreMat.isIdentity());
             REPORTER_ASSERT(reporter, 0 == info1.fBounds.fLeft && 0 == info1.fBounds.fTop);
             REPORTER_ASSERT(reporter, NULL == info1.fPaint);
             REPORTER_ASSERT(reporter, !info1.fIsNested &&
                                       info1.fHasNestedLayers); // has a nested SL
 
             REPORTER_ASSERT(reporter, NULL == info2.fPicture);
             REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.width() &&
                                       kHeight / 2 == info2.fBounds.height()); // bound reduces size
             REPORTER_ASSERT(reporter, !info2.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info2.fPreMat.isIdentity());
             REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.fLeft &&   // translated
                                       kHeight / 2 == info2.fBounds.fTop);
-            REPORTER_ASSERT(reporter, NULL == info1.fPaint);
+            REPORTER_ASSERT(reporter, NULL != info2.fPaint);
             REPORTER_ASSERT(reporter, info2.fIsNested && !info2.fHasNestedLayers); // is nested
 
             REPORTER_ASSERT(reporter, NULL == info3.fPicture);
             REPORTER_ASSERT(reporter, kWidth == info3.fBounds.width() &&
                                       kHeight == info3.fBounds.height());
             REPORTER_ASSERT(reporter, info3.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info3.fPreMat.isIdentity());
             REPORTER_ASSERT(reporter, 0 == info3.fBounds.fLeft && 0 == info3.fBounds.fTop);
             REPORTER_ASSERT(reporter, info3.fPaint);
             REPORTER_ASSERT(reporter, !info3.fIsNested && !info3.fHasNestedLayers);
 
             REPORTER_ASSERT(reporter, NULL == info4.fPicture);
             REPORTER_ASSERT(reporter, kWidth == info4.fBounds.width() &&
                                       kHeight == info4.fBounds.height());
             REPORTER_ASSERT(reporter, 0 == info4.fBounds.fLeft && 0 == info4.fBounds.fTop);
             REPORTER_ASSERT(reporter, info4.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info4.fPreMat.isIdentity());
             REPORTER_ASSERT(reporter, info4.fPaint);
             REPORTER_ASSERT(reporter, !info4.fIsNested &&
                                       info4.fHasNestedLayers); // has a nested SL
 
             REPORTER_ASSERT(reporter, child == info5.fPicture); // in a child picture
             REPORTER_ASSERT(reporter, kWidth == info5.fBounds.width() &&
                                       kHeight == info5.fBounds.height());
             REPORTER_ASSERT(reporter, 0 == info5.fBounds.fLeft && 0 == info5.fBounds.fTop);
             REPORTER_ASSERT(reporter, info5.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info5.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, NULL == info5.fPaint);
+            REPORTER_ASSERT(reporter, NULL != info5.fPaint);
             REPORTER_ASSERT(reporter, info5.fIsNested && !info5.fHasNestedLayers); // is nested
 
             REPORTER_ASSERT(reporter, NULL == info6.fPicture);
-            REPORTER_ASSERT(reporter, kWidth == info6.fBounds.width() &&
-                                      kHeight == info6.fBounds.height());
-            REPORTER_ASSERT(reporter, 0 == info6.fBounds.fLeft && 0 == info6.fBounds.fTop);
+            REPORTER_ASSERT(reporter, kWidth-10 == info6.fBounds.width() &&
+                                      kHeight-10 == info6.fBounds.height());
+            REPORTER_ASSERT(reporter, 10 == info6.fBounds.fLeft && 10 == info6.fBounds.fTop);
             REPORTER_ASSERT(reporter, info6.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info6.fPreMat.isIdentity());
             REPORTER_ASSERT(reporter, info6.fPaint);
             REPORTER_ASSERT(reporter, !info6.fIsNested &&
                                       info6.fHasNestedLayers); // has a nested SL
 
             REPORTER_ASSERT(reporter, child == info7.fPicture); // in a child picture
             REPORTER_ASSERT(reporter, kWidth == info7.fBounds.width() &&
                                       kHeight == info7.fBounds.height());
             REPORTER_ASSERT(reporter, 0 == info7.fBounds.fLeft && 0 == info7.fBounds.fTop);
             REPORTER_ASSERT(reporter, info7.fLocalMat.isIdentity());
             REPORTER_ASSERT(reporter, info7.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, NULL == info7.fPaint);
+            REPORTER_ASSERT(reporter, NULL != info7.fPaint);
             REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested
         }
     }
 }
 
 #endif
 
 static void test_has_text(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
@@ skipping 811 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());
 }