Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / third_party / skia / src / effects / SkLayerRasterizer.cpp

diff --git a/src/third_party/skia/src/effects/SkLayerRasterizer.cpp b/src/third_party/skia/src/effects/SkLayerRasterizer.cpp
index ea5808c..b331a03 100644 (file)
--- a/src/third_party/skia/src/effects/SkLayerRasterizer.cpp
+++ b/src/third_party/skia/src/effects/SkLayerRasterizer.cpp
@@ -9,7 +9,8 @@
 
 #include "SkLayerRasterizer.h"
 #include "SkDraw.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkMask.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
@@ -24,24 +25,29 @@ struct SkLayerRasterizer_Rec {
     SkVector    fOffset;
 };
 
-SkLayerRasterizer::SkLayerRasterizer() : fLayers(sizeof(SkLayerRasterizer_Rec))
+SkLayerRasterizer::SkLayerRasterizer()
+    : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
 {
 }
 
-SkLayerRasterizer::~SkLayerRasterizer() {
-    SkDeque::F2BIter        iter(fLayers);
+SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers)
+{
+}
+
+// Helper function to call destructors on SkPaints held by layers and delete layers.
+static void clean_up_layers(SkDeque* layers) {
+    SkDeque::F2BIter        iter(*layers);
     SkLayerRasterizer_Rec*  rec;
 
     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
         rec->fPaint.~SkPaint();
-}
 
-void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx,
-                                 SkScalar dy) {
-    SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
+    SkDELETE(layers);
+}
 
-    SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint));
-    rec->fOffset.set(dx, dy);
+SkLayerRasterizer::~SkLayerRasterizer() {
+    SkASSERT(fLayers);
+    clean_up_layers(const_cast<SkDeque*>(fLayers));
 }
 
 static bool compute_bounds(const SkDeque& layers, const SkPath& path,
@@ -88,12 +94,13 @@ static bool compute_bounds(const SkDeque& layers, const SkPath& path,
 bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
                                     const SkIRect* clipBounds,
                                     SkMask* mask, SkMask::CreateMode mode) const {
-    if (fLayers.empty()) {
+    SkASSERT(fLayers);
+    if (fLayers->empty()) {
         return false;
     }
 
     if (SkMask::kJustRenderImage_CreateMode != mode) {
-        if (!compute_bounds(fLayers, path, matrix, clipBounds, &mask->fBounds))
+        if (!compute_bounds(*fLayers, path, matrix, clipBounds, &mask->fBounds))
             return false;
     }
 
@@ -121,17 +128,15 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
         translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
                                        -SkIntToScalar(mask->fBounds.fTop));
 
-        device.setConfig(SkBitmap::kA8_Config, mask->fBounds.width(), mask->fBounds.height(), mask->fRowBytes);
-        device.setPixels(mask->fImage);
+        device.installMaskPixels(*mask);
 
         draw.fBitmap    = &device;
         draw.fMatrix    = &drawMatrix;
         draw.fRC        = &rectClip;
         draw.fClip      = &rectClip.bwRgn();
         // we set the matrixproc in the loop, as the matrix changes each time (potentially)
-        draw.fBounder   = NULL;
 
-        SkDeque::F2BIter        iter(fLayers);
+        SkDeque::F2BIter        iter(*fLayers);
         SkLayerRasterizer_Rec*  rec;
 
         while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
@@ -143,25 +148,36 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
     return true;
 }
 
-SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
-    : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec)) {
-    int count = buffer.readInt();
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer)
+    : SkRasterizer(buffer), fLayers(ReadLayers(buffer)) {}
+#endif
+
+SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) {
+    return SkNEW_ARGS(SkLayerRasterizer, (ReadLayers(buffer)));
+}
 
+SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) {
+    int count = buffer.readInt();
+    
+    SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)));
     for (int i = 0; i < count; i++) {
-        SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
+        SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back();
 
         SkNEW_PLACEMENT(&rec->fPaint, SkPaint);
         buffer.readPaint(&rec->fPaint);
         buffer.readPoint(&rec->fOffset);
     }
+    return layers;
 }
 
-void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
 
-    buffer.writeInt(fLayers.count());
+    SkASSERT(fLayers);
+    buffer.writeInt(fLayers->count());
 
-    SkDeque::F2BIter                iter(fLayers);
+    SkDeque::F2BIter                iter(*fLayers);
     const SkLayerRasterizer_Rec*    rec;
 
     while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
@@ -169,3 +185,56 @@ void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer) const {
         buffer.writePoint(rec->fOffset);
     }
 }
+
+SkLayerRasterizer::Builder::Builder()
+        : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
+{
+}
+
+SkLayerRasterizer::Builder::~Builder()
+{
+    if (fLayers != NULL) {
+        clean_up_layers(fLayers);
+    }
+}
+
+void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx,
+                                          SkScalar dy) {
+    SkASSERT(fLayers);
+    SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back();
+
+    SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint));
+    rec->fOffset.set(dx, dy);
+}
+
+SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() {
+    SkLayerRasterizer* rasterizer;
+    if (0 == fLayers->count()) {
+        rasterizer = NULL;
+        SkDELETE(fLayers);
+    } else {
+        rasterizer = SkNEW_ARGS(SkLayerRasterizer, (fLayers));
+    }
+    fLayers = NULL;
+    return rasterizer;
+}
+
+SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const {
+    if (0 == fLayers->count()) {
+        return NULL;
+    }
+    SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec), fLayers->count()));
+    SkDeque::F2BIter                iter(*fLayers);
+    const SkLayerRasterizer_Rec*    recOrig;
+    SkDEBUGCODE(int                 count = 0;)
+    while ((recOrig = static_cast<SkLayerRasterizer_Rec*>(iter.next())) != NULL) {
+        SkDEBUGCODE(count++);
+        SkLayerRasterizer_Rec* recCopy = static_cast<SkLayerRasterizer_Rec*>(layers->push_back());
+        SkNEW_PLACEMENT_ARGS(&recCopy->fPaint, SkPaint, (recOrig->fPaint));
+        recCopy->fOffset = recOrig->fOffset;
+    }
+    SkASSERT(fLayers->count() == count);
+    SkASSERT(layers->count() == count);
+    SkLayerRasterizer* rasterizer = SkNEW_ARGS(SkLayerRasterizer, (layers));
+    return rasterizer;
+}