Convert PictureRenderer to SkPaintFilterCanvas

tools/PictureRenderer.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 "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
 #include "SkBitmapHasher.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDevice.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkGPipe.h"
 #if SK_SUPPORT_GPU
 #include "gl/GrGLDefines.h"
 #include "SkGpuDevice.h"
 #endif
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkMaskFilter.h"
 #include "SkMatrix.h"
 #include "SkMultiPictureDraw.h"
 #include "SkOSFile.h"
+#include "SkPaintFilterCanvas.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkSurface.h"
 #include "SkTemplates.h"
@@ skipping 43 matching lines @@
 }
 
 void PictureRenderer::CopyString(SkString* dest, const SkString* src) {
     if (src) {
         dest->set(*src);
     } else {
         dest->reset();
     }
 }
 
-class FlagsDrawFilter : public SkDrawFilter {
+class FlagsFilterCanvas : public SkPaintFilterCanvas {
 public:
-    FlagsDrawFilter(PictureRenderer::DrawFilterFlags* flags) :
-        fFlags(flags) {}
+    FlagsFilterCanvas(SkCanvas* canvas, PictureRenderer::DrawFilterFlags* flags)
+        : INHERITED(canvas->imageInfo().width(), canvas->imageInfo().height())
+        , fFlags(flags) {
+        this->addCanvas(canvas);
+    }
 
-    virtual bool filter(SkPaint* paint, Type t) {
+protected:
+    void onFilterPaint(SkPaint* paint, Type t) const override {
         paint->setFlags(paint->getFlags() & ~fFlags[t] & SkPaint::kAllFlags);
         if (PictureRenderer::kMaskFilter_DrawFilterFlag & fFlags[t]) {
             SkMaskFilter* maskFilter = paint->getMaskFilter();
             if (maskFilter) {
                 paint->setMaskFilter(NULL);
             }
         }
         if (PictureRenderer::kHinting_DrawFilterFlag & fFlags[t]) {
             paint->setHinting(SkPaint::kNo_Hinting);
         } else if (PictureRenderer::kSlightHinting_DrawFilterFlag & fFlags[t]) {
             paint->setHinting(SkPaint::kSlight_Hinting);
         }
-        return true;
     }
 
 private:
-    PictureRenderer::DrawFilterFlags* fFlags;
+    const PictureRenderer::DrawFilterFlags* fFlags;
+
+    typedef SkPaintFilterCanvas INHERITED;
 };
 
-static void setUpFilter(SkCanvas* canvas, PictureRenderer::DrawFilterFlags* drawFilters) {
-    if (drawFilters && !canvas->getDrawFilter()) {
-        canvas->setDrawFilter(SkNEW_ARGS(FlagsDrawFilter, (drawFilters)))->unref();
-        if (drawFilters[0] & PictureRenderer::kAAClip_DrawFilterFlag) {
-            canvas->setAllowSoftClip(false);
-        }
-    }
-}
-
 SkCanvas* PictureRenderer::setupCanvas() {
     const int width = this->getViewWidth();
     const int height = this->getViewHeight();
     return this->setupCanvas(width, height);
 }
 
 SkCanvas* PictureRenderer::setupCanvas(int width, int height) {
-    SkCanvas* canvas;
+    SkAutoTUnref<SkCanvas> canvas;
+
     switch(fDeviceType) {
         case kBitmap_DeviceType: {
             SkBitmap bitmap;
             sk_tools::setup_bitmap(&bitmap, width, height);
-            canvas = SkNEW_ARGS(SkCanvas, (bitmap));
+            canvas.reset(SkNEW_ARGS(SkCanvas, (bitmap)));
         }
         break;
 #if SK_SUPPORT_GPU
 #if SK_ANGLE
         case kAngle_DeviceType:
             // fall through
 #endif
 #if SK_MESA
         case kMesa_DeviceType:
             // fall through
@@ skipping 11 matching lines @@
                 desc.fSampleCnt = fSampleCount;
                 target.reset(fGrContext->textureProvider()->createTexture(desc, false, NULL, 0));
             }
 
             uint32_t flags = fUseDFText ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
             SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
             SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(target->asRenderTarget(), &props));
             if (!device) {
                 return NULL;
             }
-            canvas = SkNEW_ARGS(SkCanvas, (device));
+            canvas.reset(SkNEW_ARGS(SkCanvas, (device)));
             break;
         }
 #endif
         default:
             SkASSERT(0);
             return NULL;
     }
-    setUpFilter(canvas, fDrawFilters);
+
+    if (fHasDrawFilters) {
+        if (fDrawFilters[0] & PictureRenderer::kAAClip_DrawFilterFlag) {
+            canvas->setAllowSoftClip(false);
+        }
+
+        canvas.reset(SkNEW_ARGS(FlagsFilterCanvas, (canvas.get(), fDrawFilters)));
+    }
+
     this->scaleToScaleFactor(canvas);
 
     // Pictures often lie about their extent (i.e., claim to be 100x100 but
     // only ever draw to 90x100). Clear here so the undrawn portion will have
     // a consistent color
     canvas->clear(SK_ColorTRANSPARENT);
-    return canvas;
+    return canvas.detach();
 }
 
 void PictureRenderer::scaleToScaleFactor(SkCanvas* canvas) {
     SkASSERT(canvas != NULL);
     if (fScaleFactor != SK_Scalar1) {
         canvas->scale(fScaleFactor, fScaleFactor);
     }
 }
 
 void PictureRenderer::end() {
@@ skipping 619 matching lines @@
         case kNone_BBoxHierarchyType:
             return NULL;
         case kRTree_BBoxHierarchyType:
             return SkNEW(SkRTreeFactory);
     }
     SkASSERT(0); // invalid bbhType
     return NULL;
 }
 
 } // namespace sk_tools