NoSaveLayerCanvas now its own file

src/utils/SkPictureUtils.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 "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkData.h"
+#include "SkNoSaveLayerCanvas.h"
 #include "SkPictureUtils.h"
 #include "SkPixelRef.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 
 class PixelRefSet {
 public:
     PixelRefSet(SkTDArray<SkPixelRef*>* array) : fArray(array) {}
 
     // This does a linear search on existing pixelrefs, so if this list gets big
@@ skipping 36 matching lines @@
 
     virtual uint32_t getDeviceCapabilities() SK_OVERRIDE { return 0; }
     virtual int width() const SK_OVERRIDE { return fSize.width(); }
     virtual int height() const SK_OVERRIDE { return fSize.height(); }
     virtual bool isOpaque() const SK_OVERRIDE { return false; }
     virtual SkBitmap::Config config() const SK_OVERRIDE {
         return SkBitmap::kNo_Config;
     }
     virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE { return NULL; }
     virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE {
-        return true;
+        return false;
     }
     // TODO: allow this call to return failure, or move to SkBitmapDevice only.
     virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE {
         return fEmptyBitmap;
     }
     virtual void lockPixels() SK_OVERRIDE { nothing_to_do(); }
     virtual void unlockPixels() SK_OVERRIDE { nothing_to_do(); }
     virtual bool allowImageFilter(SkImageFilter*) SK_OVERRIDE { return false; }
     virtual bool canHandleImageFilter(SkImageFilter*) SK_OVERRIDE { return false; }
     virtual bool filterImage(SkImageFilter*, const SkBitmap&, const SkMatrix&,
@@ skipping 114 matching lines @@
           if (SkShader::kNone_GradientType == shader->asAGradient(NULL) &&
               shader->asABitmap(&bm, NULL, NULL)) {
               fPRSet->add(bm.pixelRef());
           }
       }
     }
 
     typedef SkBaseDevice INHERITED;
 };
 
-class NoSaveLayerCanvas : public SkCanvas {
-public:
-    NoSaveLayerCanvas(SkBaseDevice* device) : INHERITED(device) {}
-
-    // turn saveLayer() into save() for speed, should not affect correctness.
-    virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,
-                          SaveFlags flags) SK_OVERRIDE {
-
-        // Like SkPictureRecord, we don't want to create layers, but we do need
-        // to respect the save and (possibly) its rect-clip.
-
-        int count = this->INHERITED::save(flags);
-        if (bounds) {
-            this->INHERITED::clipRectBounds(bounds, flags, NULL);
-        }
-        return count;
-    }
-
-    // disable aa for speed
-    virtual bool clipRect(const SkRect& rect, SkRegion::Op op,
-                          bool doAA) SK_OVERRIDE {
-        return this->INHERITED::clipRect(rect, op, false);
-    }
-
-    // for speed, just respect the bounds, and disable AA. May give us a few
-    // false positives and negatives.
-    virtual bool clipPath(const SkPath& path, SkRegion::Op op,
-                          bool doAA) SK_OVERRIDE {
-        return this->updateClipConservativelyUsingBounds(path.getBounds(), op, path.isInverseFillType());
-    }
-    virtual bool clipRRect(const SkRRect& rrect, SkRegion::Op op,
-                           bool doAA) SK_OVERRIDE {
-        return this->updateClipConservativelyUsingBounds(rrect.getBounds(), op, false);
-    }
-
-private:
-    typedef SkCanvas INHERITED;
-};
-
 SkData* SkPictureUtils::GatherPixelRefs(SkPicture* pict, const SkRect& area) {
     if (NULL == pict) {
         return NULL;
     }
 
     // this test also handles if either area or pict's width/height are empty
     if (!SkRect::Intersects(area,
                             SkRect::MakeWH(SkIntToScalar(pict->width()),
                                            SkIntToScalar(pict->height())))) {
         return NULL;
     }
 
     SkTDArray<SkPixelRef*> array;
     PixelRefSet prset(&array);
 
     GatherPixelRefDevice device(pict->width(), pict->height(), &prset);
-    NoSaveLayerCanvas canvas(&device);
+    SkNoSaveLayerCanvas canvas(&device);
 
     canvas.clipRect(area, SkRegion::kIntersect_Op, false);
     canvas.drawPicture(*pict);
 
     SkData* data = NULL;
     int count = array.count();
     if (count > 0) {
         data = SkData::NewFromMalloc(array.detach(), count * sizeof(SkPixelRef*));
     }
     return data;
 }