diff options
Diffstat (limited to 'chromium/third_party/skia/src/utils/debugger')
6 files changed, 712 insertions, 242 deletions
diff --git a/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.cpp b/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.cpp index e491f3b8a79..8f6dc1b7a27 100644 --- a/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.cpp +++ b/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.cpp @@ -14,17 +14,13 @@ #include "SkDevice.h" #include "SkXfermode.h" -static SkBitmap make_noconfig_bm(int width, int height) { - SkBitmap bm; - bm.setConfig(SkBitmap::kNo_Config, width, height); - return bm; -} - SkDebugCanvas::SkDebugCanvas(int width, int height) - : INHERITED(make_noconfig_bm(width, height)) + : INHERITED(width, height) + , fPicture(NULL) , fWidth(width) , fHeight(height) , fFilter(false) + , fMegaVizMode(false) , fIndex(0) , fOverdrawViz(false) , fOverdrawFilter(NULL) @@ -49,7 +45,8 @@ SkDebugCanvas::SkDebugCanvas(int width, int height) large.roundOut(&largeIRect); SkASSERT(!largeIRect.isEmpty()); #endif - INHERITED::clipRect(large, SkRegion::kReplace_Op, false); + // call the base class' version to avoid adding a draw command + this->INHERITED::onClipRect(large, SkRegion::kReplace_Op, kHard_ClipEdgeStyle); } SkDebugCanvas::~SkDebugCanvas() { @@ -59,12 +56,13 @@ SkDebugCanvas::~SkDebugCanvas() { } void SkDebugCanvas::addDrawCommand(SkDrawCommand* command) { + command->setOffset(this->getOpID()); fCommandVector.push(command); } void SkDebugCanvas::draw(SkCanvas* canvas) { if (!fCommandVector.isEmpty()) { - drawTo(canvas, fCommandVector.count() - 1); + this->drawTo(canvas, fCommandVector.count() - 1); } } @@ -74,8 +72,7 @@ void SkDebugCanvas::applyUserTransform(SkCanvas* canvas) { int SkDebugCanvas::getCommandAtPoint(int x, int y, int index) { SkBitmap bitmap; - bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1, 1); - bitmap.allocPixels(); + bitmap.allocPixels(SkImageInfo::MakeN32Premul(1, 1)); SkCanvas canvas(bitmap); canvas.translate(SkIntToScalar(-x), SkIntToScalar(-y)); @@ -95,37 +92,43 @@ int SkDebugCanvas::getCommandAtPoint(int x, int y, int index) { return layer; } -static SkPMColor OverdrawXferModeProc(SkPMColor src, SkPMColor dst) { - // This table encodes the color progression of the overdraw visualization - static const SkPMColor gTable[] = { - SkPackARGB32(0x00, 0x00, 0x00, 0x00), - SkPackARGB32(0xFF, 128, 158, 255), - SkPackARGB32(0xFF, 170, 185, 212), - SkPackARGB32(0xFF, 213, 195, 170), - SkPackARGB32(0xFF, 255, 192, 127), - SkPackARGB32(0xFF, 255, 185, 85), - SkPackARGB32(0xFF, 255, 165, 42), - SkPackARGB32(0xFF, 255, 135, 0), - SkPackARGB32(0xFF, 255, 95, 0), - SkPackARGB32(0xFF, 255, 50, 0), - SkPackARGB32(0xFF, 255, 0, 0) - }; - - for (size_t i = 0; i < SK_ARRAY_COUNT(gTable)-1; ++i) { - if (gTable[i] == dst) { - return gTable[i+1]; +class OverdrawXfermode : public SkXfermode { +public: + virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const SK_OVERRIDE { + // This table encodes the color progression of the overdraw visualization + static const SkPMColor gTable[] = { + SkPackARGB32(0x00, 0x00, 0x00, 0x00), + SkPackARGB32(0xFF, 128, 158, 255), + SkPackARGB32(0xFF, 170, 185, 212), + SkPackARGB32(0xFF, 213, 195, 170), + SkPackARGB32(0xFF, 255, 192, 127), + SkPackARGB32(0xFF, 255, 185, 85), + SkPackARGB32(0xFF, 255, 165, 42), + SkPackARGB32(0xFF, 255, 135, 0), + SkPackARGB32(0xFF, 255, 95, 0), + SkPackARGB32(0xFF, 255, 50, 0), + SkPackARGB32(0xFF, 255, 0, 0) + }; + + for (size_t i = 0; i < SK_ARRAY_COUNT(gTable)-1; ++i) { + if (gTable[i] == dst) { + return gTable[i+1]; + } } + + return gTable[SK_ARRAY_COUNT(gTable)-1]; } - return gTable[SK_ARRAY_COUNT(gTable)-1]; -} + virtual Factory getFactory() const SK_OVERRIDE { return NULL; } +#ifndef SK_IGNORE_TO_STRING + virtual void toString(SkString* str) const { str->set("OverdrawXfermode"); } +#endif +}; -// The OverdrawFilter modifies every paint to use an SkProcXfermode which -// in turn invokes OverdrawXferModeProc class SkOverdrawFilter : public SkDrawFilter { public: SkOverdrawFilter() { - fXferMode = new SkProcXfermode(OverdrawXferModeProc); + fXferMode = SkNEW(OverdrawXfermode); } virtual ~SkOverdrawFilter() { @@ -167,17 +170,84 @@ private: typedef SkDrawFilter INHERITED; }; +class SkDebugClipVisitor : public SkCanvas::ClipVisitor { +public: + SkDebugClipVisitor(SkCanvas* canvas) : fCanvas(canvas) {} + + virtual void clipRect(const SkRect& r, SkRegion::Op, bool doAA) SK_OVERRIDE { + SkPaint p; + p.setColor(SK_ColorRED); + p.setStyle(SkPaint::kStroke_Style); + p.setAntiAlias(doAA); + fCanvas->drawRect(r, p); + } + virtual void clipRRect(const SkRRect& rr, SkRegion::Op, bool doAA) SK_OVERRIDE { + SkPaint p; + p.setColor(SK_ColorGREEN); + p.setStyle(SkPaint::kStroke_Style); + p.setAntiAlias(doAA); + fCanvas->drawRRect(rr, p); + } + virtual void clipPath(const SkPath& path, SkRegion::Op, bool doAA) SK_OVERRIDE { + SkPaint p; + p.setColor(SK_ColorBLUE); + p.setStyle(SkPaint::kStroke_Style); + p.setAntiAlias(doAA); + fCanvas->drawPath(path, p); + } + +protected: + SkCanvas* fCanvas; + +private: + typedef SkCanvas::ClipVisitor INHERITED; +}; + +// set up the saveLayer commands so that the active ones +// return true in their 'active' method +void SkDebugCanvas::markActiveCommands(int index) { + fActiveLayers.rewind(); + fActiveCulls.rewind(); + + for (int i = 0; i < fCommandVector.count(); ++i) { + fCommandVector[i]->setActive(false); + } + + for (int i = 0; i < index; ++i) { + SkDrawCommand::Action result = fCommandVector[i]->action(); + if (SkDrawCommand::kPushLayer_Action == result) { + fActiveLayers.push(fCommandVector[i]); + } else if (SkDrawCommand::kPopLayer_Action == result) { + fActiveLayers.pop(); + } else if (SkDrawCommand::kPushCull_Action == result) { + fActiveCulls.push(fCommandVector[i]); + } else if (SkDrawCommand::kPopCull_Action == result) { + fActiveCulls.pop(); + } + } + + for (int i = 0; i < fActiveLayers.count(); ++i) { + fActiveLayers[i]->setActive(true); + } + + for (int i = 0; i < fActiveCulls.count(); ++i) { + fActiveCulls[i]->setActive(true); + } +} + void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) { SkASSERT(!fCommandVector.isEmpty()); SkASSERT(index < fCommandVector.count()); int i = 0; + bool pathOpsMode = getAllowSimplifyClip(); + canvas->setAllowSimplifyClip(pathOpsMode); // This only works assuming the canvas and device are the same ones that // were previously drawn into because they need to preserve all saves // and restores. // The visibility filter also requires a full re-draw - otherwise we can // end up drawing the filter repeatedly. - if (fIndex < index && !fFilter) { + if (fIndex < index && !fFilter && !fMegaVizMode && !pathOpsMode) { i = fIndex + 1; } else { for (int j = 0; j < fOutstandingSaveCount; j++) { @@ -216,6 +286,10 @@ void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) { canvas->setDrawFilter(NULL); } + if (fMegaVizMode) { + this->markActiveCommands(index); + } + for (; i <= index; i++) { if (i == index && fFilter) { SkPaint p; @@ -232,12 +306,63 @@ void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) { } if (fCommandVector[i]->isVisible()) { - fCommandVector[i]->execute(canvas); + if (fMegaVizMode && fCommandVector[i]->active()) { + // "active" commands execute their visualization behaviors: + // All active saveLayers get replaced with saves so all draws go to the + // visible canvas. + // All active culls draw their cull box + fCommandVector[i]->vizExecute(canvas); + } else { + fCommandVector[i]->execute(canvas); + } + fCommandVector[i]->trackSaveState(&fOutstandingSaveCount); } } + + if (fMegaVizMode) { + SkRect r = SkRect::MakeWH(SkIntToScalar(fWidth), SkIntToScalar(fHeight)); + r.outset(SK_Scalar1, SK_Scalar1); + + canvas->save(); + // nuke the CTM + canvas->setMatrix(SkMatrix::I()); + // turn off clipping + canvas->clipRect(r, SkRegion::kReplace_Op); + + // visualize existing clips + SkDebugClipVisitor visitor(canvas); + + canvas->replayClips(&visitor); + + canvas->restore(); + } + if (pathOpsMode) { + this->resetClipStackData(); + const SkClipStack* clipStack = canvas->getClipStack(); + SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart); + const SkClipStack::Element* element; + SkPath devPath; + while ((element = iter.next())) { + SkClipStack::Element::Type type = element->getType(); + SkPath operand; + if (type != SkClipStack::Element::kEmpty_Type) { + element->asPath(&operand); + } + SkRegion::Op elementOp = element->getOp(); + this->addClipStackData(devPath, operand, elementOp); + if (elementOp == SkRegion::kReplace_Op) { + devPath = operand; + } else { + Op(devPath, operand, (SkPathOp) elementOp, &devPath); + } + } + this->lastClipStackData(devPath); + } fMatrix = canvas->getTotalMatrix(); - fClip = canvas->getTotalClip().getBounds(); + if (!canvas->getClipDeviceBounds(&fClip)) { + fClip.setEmpty(); + } fIndex = index; } @@ -287,8 +412,14 @@ SkTArray<SkString>* SkDebugCanvas::getDrawCommandsAsStrings() const { return commandString; } -void SkDebugCanvas::toggleFilter(bool toggle) { - fFilter = toggle; +SkTDArray<size_t>* SkDebugCanvas::getDrawCommandOffsets() const { + SkTDArray<size_t>* commandOffsets = new SkTDArray<size_t>; + if (!fCommandVector.isEmpty()) { + for (int i = 0; i < fCommandVector.count(); i ++) { + *commandOffsets->push() = fCommandVector[i]->offset(); + } + } + return commandOffsets; } void SkDebugCanvas::overrideTexFiltering(bool overrideTexFiltering, SkPaint::FilterLevel level) { @@ -301,101 +432,110 @@ void SkDebugCanvas::overrideTexFiltering(bool overrideTexFiltering, SkPaint::Fil } void SkDebugCanvas::clear(SkColor color) { - addDrawCommand(new SkClearCommand(color)); + this->addDrawCommand(new SkClearCommand(color)); } -bool SkDebugCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) { - addDrawCommand(new SkClipPathCommand(path, op, doAA)); - return true; +void SkDebugCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) { + this->addDrawCommand(new SkClipPathCommand(path, op, kSoft_ClipEdgeStyle == edgeStyle)); } -bool SkDebugCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) { - addDrawCommand(new SkClipRectCommand(rect, op, doAA)); - return true; +void SkDebugCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) { + this->addDrawCommand(new SkClipRectCommand(rect, op, kSoft_ClipEdgeStyle == edgeStyle)); } -bool SkDebugCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) { - addDrawCommand(new SkClipRRectCommand(rrect, op, doAA)); - return true; +void SkDebugCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) { + this->addDrawCommand(new SkClipRRectCommand(rrect, op, kSoft_ClipEdgeStyle == edgeStyle)); } -bool SkDebugCanvas::clipRegion(const SkRegion& region, SkRegion::Op op) { - addDrawCommand(new SkClipRegionCommand(region, op)); - return true; +void SkDebugCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op) { + this->addDrawCommand(new SkClipRegionCommand(region, op)); } -bool SkDebugCanvas::concat(const SkMatrix& matrix) { - addDrawCommand(new SkConcatCommand(matrix)); - return true; +void SkDebugCanvas::didConcat(const SkMatrix& matrix) { + switch (matrix.getType()) { + case SkMatrix::kTranslate_Mask: + this->addDrawCommand(new SkTranslateCommand(matrix.getTranslateX(), + matrix.getTranslateY())); + break; + case SkMatrix::kScale_Mask: + this->addDrawCommand(new SkScaleCommand(matrix.getScaleX(), + matrix.getScaleY())); + break; + default: + this->addDrawCommand(new SkConcatCommand(matrix)); + break; + } + + this->INHERITED::didConcat(matrix); } void SkDebugCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint = NULL) { - addDrawCommand(new SkDrawBitmapCommand(bitmap, left, top, paint)); + this->addDrawCommand(new SkDrawBitmapCommand(bitmap, left, top, paint)); } void SkDebugCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, const SkPaint* paint, SkCanvas::DrawBitmapRectFlags flags) { - addDrawCommand(new SkDrawBitmapRectCommand(bitmap, src, dst, paint, flags)); + this->addDrawCommand(new SkDrawBitmapRectCommand(bitmap, src, dst, paint, flags)); } void SkDebugCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) { - addDrawCommand(new SkDrawBitmapMatrixCommand(bitmap, matrix, paint)); + this->addDrawCommand(new SkDrawBitmapMatrixCommand(bitmap, matrix, paint)); } void SkDebugCanvas::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint) { - addDrawCommand(new SkDrawBitmapNineCommand(bitmap, center, dst, paint)); + this->addDrawCommand(new SkDrawBitmapNineCommand(bitmap, center, dst, paint)); } void SkDebugCanvas::drawData(const void* data, size_t length) { - addDrawCommand(new SkDrawDataCommand(data, length)); + this->addDrawCommand(new SkDrawDataCommand(data, length)); } void SkDebugCanvas::beginCommentGroup(const char* description) { - addDrawCommand(new SkBeginCommentGroupCommand(description)); + this->addDrawCommand(new SkBeginCommentGroupCommand(description)); } void SkDebugCanvas::addComment(const char* kywd, const char* value) { - addDrawCommand(new SkCommentCommand(kywd, value)); + this->addDrawCommand(new SkCommentCommand(kywd, value)); } void SkDebugCanvas::endCommentGroup() { - addDrawCommand(new SkEndCommentGroupCommand()); + this->addDrawCommand(new SkEndCommentGroupCommand()); } void SkDebugCanvas::drawOval(const SkRect& oval, const SkPaint& paint) { - addDrawCommand(new SkDrawOvalCommand(oval, paint)); + this->addDrawCommand(new SkDrawOvalCommand(oval, paint)); } void SkDebugCanvas::drawPaint(const SkPaint& paint) { - addDrawCommand(new SkDrawPaintCommand(paint)); + this->addDrawCommand(new SkDrawPaintCommand(paint)); } void SkDebugCanvas::drawPath(const SkPath& path, const SkPaint& paint) { - addDrawCommand(new SkDrawPathCommand(path, paint)); + this->addDrawCommand(new SkDrawPathCommand(path, paint)); } -void SkDebugCanvas::drawPicture(SkPicture& picture) { - addDrawCommand(new SkDrawPictureCommand(picture)); +void SkDebugCanvas::onDrawPicture(const SkPicture* picture) { + this->addDrawCommand(new SkDrawPictureCommand(picture)); } void SkDebugCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) { - addDrawCommand(new SkDrawPointsCommand(mode, count, pts, paint)); + this->addDrawCommand(new SkDrawPointsCommand(mode, count, pts, paint)); } -void SkDebugCanvas::drawPosText(const void* text, size_t byteLength, - const SkPoint pos[], const SkPaint& paint) { - addDrawCommand(new SkDrawPosTextCommand(text, byteLength, pos, paint)); +void SkDebugCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[], + const SkPaint& paint) { + this->addDrawCommand(new SkDrawPosTextCommand(text, byteLength, pos, paint)); } -void SkDebugCanvas::drawPosTextH(const void* text, size_t byteLength, - const SkScalar xpos[], SkScalar constY, const SkPaint& paint) { - addDrawCommand( +void SkDebugCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], + SkScalar constY, const SkPaint& paint) { + this->addDrawCommand( new SkDrawPosTextHCommand(text, byteLength, xpos, constY, paint)); } @@ -405,22 +545,27 @@ void SkDebugCanvas::drawRect(const SkRect& rect, const SkPaint& paint) { } void SkDebugCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) { - addDrawCommand(new SkDrawRRectCommand(rrect, paint)); + this->addDrawCommand(new SkDrawRRectCommand(rrect, paint)); +} + +void SkDebugCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, + const SkPaint& paint) { + this->addDrawCommand(new SkDrawDRRectCommand(outer, inner, paint)); } void SkDebugCanvas::drawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint = NULL) { - addDrawCommand(new SkDrawSpriteCommand(bitmap, left, top, paint)); + this->addDrawCommand(new SkDrawSpriteCommand(bitmap, left, top, paint)); } -void SkDebugCanvas::drawText(const void* text, size_t byteLength, SkScalar x, - SkScalar y, const SkPaint& paint) { - addDrawCommand(new SkDrawTextCommand(text, byteLength, x, y, paint)); +void SkDebugCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, + const SkPaint& paint) { + this->addDrawCommand(new SkDrawTextCommand(text, byteLength, x, y, paint)); } -void SkDebugCanvas::drawTextOnPath(const void* text, size_t byteLength, - const SkPath& path, const SkMatrix* matrix, const SkPaint& paint) { - addDrawCommand( +void SkDebugCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, + const SkMatrix* matrix, const SkPaint& paint) { + this->addDrawCommand( new SkDrawTextOnPathCommand(text, byteLength, path, matrix, paint)); } @@ -428,50 +573,167 @@ void SkDebugCanvas::drawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode*, const uint16_t indices[], int indexCount, const SkPaint& paint) { - addDrawCommand(new SkDrawVerticesCommand(vmode, vertexCount, vertices, - texs, colors, NULL, indices, indexCount, paint)); + this->addDrawCommand(new SkDrawVerticesCommand(vmode, vertexCount, vertices, + texs, colors, NULL, indices, indexCount, paint)); } -void SkDebugCanvas::restore() { - addDrawCommand(new SkRestoreCommand()); +void SkDebugCanvas::onPushCull(const SkRect& cullRect) { + this->addDrawCommand(new SkPushCullCommand(cullRect)); } -bool SkDebugCanvas::rotate(SkScalar degrees) { - addDrawCommand(new SkRotateCommand(degrees)); - return true; +void SkDebugCanvas::onPopCull() { + this->addDrawCommand(new SkPopCullCommand()); } -int SkDebugCanvas::save(SaveFlags flags) { - addDrawCommand(new SkSaveCommand(flags)); - return true; +void SkDebugCanvas::willRestore() { + this->addDrawCommand(new SkRestoreCommand()); + this->INHERITED::willRestore(); } -int SkDebugCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, - SaveFlags flags) { - addDrawCommand(new SkSaveLayerCommand(bounds, paint, flags)); - return true; +void SkDebugCanvas::willSave(SaveFlags flags) { + this->addDrawCommand(new SkSaveCommand(flags)); + this->INHERITED::willSave(flags); } -bool SkDebugCanvas::scale(SkScalar sx, SkScalar sy) { - addDrawCommand(new SkScaleCommand(sx, sy)); - return true; +SkCanvas::SaveLayerStrategy SkDebugCanvas::willSaveLayer(const SkRect* bounds, const SkPaint* paint, + SaveFlags flags) { + this->addDrawCommand(new SkSaveLayerCommand(bounds, paint, flags)); + this->INHERITED::willSaveLayer(bounds, paint, flags); + // No need for a full layer. + return kNoLayer_SaveLayerStrategy; +} + +void SkDebugCanvas::didSetMatrix(const SkMatrix& matrix) { + this->addDrawCommand(new SkSetMatrixCommand(matrix)); + this->INHERITED::didSetMatrix(matrix); +} + +void SkDebugCanvas::toggleCommand(int index, bool toggle) { + SkASSERT(index < fCommandVector.count()); + fCommandVector[index]->setVisible(toggle); +} + +static const char* gFillTypeStrs[] = { + "kWinding_FillType", + "kEvenOdd_FillType", + "kInverseWinding_FillType", + "kInverseEvenOdd_FillType" +}; + +static const char* gOpStrs[] = { + "kDifference_PathOp", + "kIntersect_PathOp", + "kUnion_PathOp", + "kXor_PathOp", + "kReverseDifference_PathOp", +}; + +static const char kHTML4SpaceIndent[] = " "; + +void SkDebugCanvas::outputScalar(SkScalar num) { + if (num == (int) num) { + fClipStackData.appendf("%d", (int) num); + } else { + SkString str; + str.printf("%1.9g", num); + int width = (int) str.size(); + const char* cStr = str.c_str(); + while (cStr[width - 1] == '0') { + --width; + } + str.resize(width); + fClipStackData.appendf("%sf", str.c_str()); + } } -void SkDebugCanvas::setMatrix(const SkMatrix& matrix) { - addDrawCommand(new SkSetMatrixCommand(matrix)); +void SkDebugCanvas::outputPointsCommon(const SkPoint* pts, int count) { + for (int index = 0; index < count; ++index) { + this->outputScalar(pts[index].fX); + fClipStackData.appendf(", "); + this->outputScalar(pts[index].fY); + if (index + 1 < count) { + fClipStackData.appendf(", "); + } + } } -bool SkDebugCanvas::skew(SkScalar sx, SkScalar sy) { - addDrawCommand(new SkSkewCommand(sx, sy)); - return true; +void SkDebugCanvas::outputPoints(const SkPoint* pts, int count) { + this->outputPointsCommon(pts, count); + fClipStackData.appendf(");<br>"); +} + +void SkDebugCanvas::outputConicPoints(const SkPoint* pts, SkScalar weight) { + this->outputPointsCommon(pts, 2); + fClipStackData.appendf(", "); + this->outputScalar(weight); + fClipStackData.appendf(");<br>"); +} + +void SkDebugCanvas::addPathData(const SkPath& path, const char* pathName) { + SkPath::RawIter iter(path); + SkPath::FillType fillType = path.getFillType(); + fClipStackData.appendf("%sSkPath %s;<br>", kHTML4SpaceIndent, pathName); + fClipStackData.appendf("%s%s.setFillType(SkPath::%s);<br>", kHTML4SpaceIndent, pathName, + gFillTypeStrs[fillType]); + iter.setPath(path); + uint8_t verb; + SkPoint pts[4]; + while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { + switch (verb) { + case SkPath::kMove_Verb: + fClipStackData.appendf("%s%s.moveTo(", kHTML4SpaceIndent, pathName); + this->outputPoints(&pts[0], 1); + continue; + case SkPath::kLine_Verb: + fClipStackData.appendf("%s%s.lineTo(", kHTML4SpaceIndent, pathName); + this->outputPoints(&pts[1], 1); + break; + case SkPath::kQuad_Verb: + fClipStackData.appendf("%s%s.quadTo(", kHTML4SpaceIndent, pathName); + this->outputPoints(&pts[1], 2); + break; + case SkPath::kConic_Verb: + fClipStackData.appendf("%s%s.conicTo(", kHTML4SpaceIndent, pathName); + this->outputConicPoints(&pts[1], iter.conicWeight()); + break; + case SkPath::kCubic_Verb: + fClipStackData.appendf("%s%s.cubicTo(", kHTML4SpaceIndent, pathName); + this->outputPoints(&pts[1], 3); + break; + case SkPath::kClose_Verb: + fClipStackData.appendf("%s%s.close();<br>", kHTML4SpaceIndent, pathName); + break; + default: + SkDEBUGFAIL("bad verb"); + return; + } + } } -bool SkDebugCanvas::translate(SkScalar dx, SkScalar dy) { - addDrawCommand(new SkTranslateCommand(dx, dy)); - return true; +void SkDebugCanvas::addClipStackData(const SkPath& devPath, const SkPath& operand, + SkRegion::Op elementOp) { + if (elementOp == SkRegion::kReplace_Op) { + if (!lastClipStackData(devPath)) { + fSaveDevPath = operand; + } + fCalledAddStackData = false; + } else { + fClipStackData.appendf("<br>static void test(skiatest::Reporter* reporter," + " const char* filename) {<br>"); + addPathData(fCalledAddStackData ? devPath : fSaveDevPath, "path"); + addPathData(operand, "pathB"); + fClipStackData.appendf("%stestPathOp(reporter, path, pathB, %s, filename);<br>", + kHTML4SpaceIndent, gOpStrs[elementOp]); + fClipStackData.appendf("}<br>"); + fCalledAddStackData = true; + } } -void SkDebugCanvas::toggleCommand(int index, bool toggle) { - SkASSERT(index < fCommandVector.count()); - fCommandVector[index]->setVisible(toggle); +bool SkDebugCanvas::lastClipStackData(const SkPath& devPath) { + if (fCalledAddStackData) { + fClipStackData.appendf("<br>"); + addPathData(devPath, "pathOut"); + return true; + } + return false; } diff --git a/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.h b/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.h index 262619e7f19..f15b397251e 100644 --- a/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.h +++ b/chromium/third_party/skia/src/utils/debugger/SkDebugCanvas.h @@ -12,6 +12,7 @@ #include "SkCanvas.h" #include "SkDrawCommand.h" +#include "SkPathOps.h" #include "SkPicture.h" #include "SkTArray.h" #include "SkString.h" @@ -23,12 +24,23 @@ public: SkDebugCanvas(int width, int height); virtual ~SkDebugCanvas(); - void toggleFilter(bool toggle); + void toggleFilter(bool toggle) { fFilter = toggle; } + + void setMegaVizMode(bool megaVizMode) { fMegaVizMode = megaVizMode; } + bool getMegaVizMode() const { return fMegaVizMode; } /** * Enable or disable overdraw visualization */ void setOverdrawViz(bool overdrawViz) { fOverdrawViz = overdrawViz; } + bool getOverdrawViz() const { return fOverdrawViz; } + + void setOutstandingSaveCount(int saveCount) { fOutstandingSaveCount = saveCount; } + int getOutstandingSaveCount() const { return fOutstandingSaveCount; } + + bool getAllowSimplifyClip() const { return fAllowSimplifyClip; } + + void setPicture(SkPicture* picture) { fPicture = picture; } /** * Enable or disable texure filtering override @@ -116,6 +128,11 @@ public: SkTArray<SkString>* getDrawCommandsAsStrings() const; /** + * Returns an array containing an offset (in the SkPicture) for each command + */ + SkTDArray<size_t>* getDrawCommandOffsets() const; + + /** Returns length of draw command vector. */ int getSize() const { @@ -137,24 +154,14 @@ public: fUserMatrix = matrix; } + SkString clipStackData() const { return fClipStackData; } + //////////////////////////////////////////////////////////////////////////////// // Inherited from SkCanvas //////////////////////////////////////////////////////////////////////////////// virtual void clear(SkColor) SK_OVERRIDE; - virtual bool clipPath(const SkPath&, SkRegion::Op, bool) SK_OVERRIDE; - - virtual bool clipRect(const SkRect&, SkRegion::Op, bool) SK_OVERRIDE; - - virtual bool clipRRect(const SkRRect& rrect, - SkRegion::Op op = SkRegion::kIntersect_Op, - bool doAntiAlias = false) SK_OVERRIDE; - - virtual bool clipRegion(const SkRegion& region, SkRegion::Op op) SK_OVERRIDE; - - virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE; - virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE; @@ -182,18 +189,9 @@ public: virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE; - virtual void drawPicture(SkPicture& picture) SK_OVERRIDE; - virtual void drawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE; - virtual void drawPosText(const void* text, size_t byteLength, - const SkPoint pos[], const SkPaint&) SK_OVERRIDE; - - virtual void drawPosTextH(const void* text, size_t byteLength, - const SkScalar xpos[], SkScalar constY, - const SkPaint&) SK_OVERRIDE; - virtual void drawRect(const SkRect& rect, const SkPaint&) SK_OVERRIDE; virtual void drawRRect(const SkRRect& rrect, const SkPaint& paint) SK_OVERRIDE; @@ -201,48 +199,82 @@ public: virtual void drawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE; - virtual void drawText(const void* text, size_t byteLength, SkScalar x, - SkScalar y, const SkPaint&) SK_OVERRIDE; - - virtual void drawTextOnPath(const void* text, size_t byteLength, - const SkPath& path, const SkMatrix* matrix, - const SkPaint&) SK_OVERRIDE; - virtual void drawVertices(VertexMode, int vertexCount, const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode*, const uint16_t indices[], int indexCount, const SkPaint&) SK_OVERRIDE; - virtual void restore() SK_OVERRIDE; - - virtual bool rotate(SkScalar degrees) SK_OVERRIDE; + static const int kVizImageHeight = 256; + static const int kVizImageWidth = 256; - virtual int save(SaveFlags) SK_OVERRIDE; + virtual bool isClipEmpty() const SK_OVERRIDE { return false; } + virtual bool isClipRect() const SK_OVERRIDE { return true; } +#ifdef SK_SUPPORT_LEGACY_GETCLIPTYPE + virtual ClipType getClipType() const SK_OVERRIDE { + return kRect_ClipType; + } +#endif + virtual bool getClipBounds(SkRect* bounds) const SK_OVERRIDE { + if (NULL != bounds) { + bounds->setXYWH(0, 0, + SkIntToScalar(this->imageInfo().fWidth), + SkIntToScalar(this->imageInfo().fHeight)); + } + return true; + } + virtual bool getClipDeviceBounds(SkIRect* bounds) const SK_OVERRIDE { + if (NULL != bounds) { + bounds->setLargest(); + } + return true; + } - virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags) SK_OVERRIDE; +protected: + virtual void willSave(SaveFlags) SK_OVERRIDE; + virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE; + virtual void willRestore() SK_OVERRIDE; - virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE; + virtual void didConcat(const SkMatrix&) SK_OVERRIDE; + virtual void didSetMatrix(const SkMatrix&) SK_OVERRIDE; - virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE; + virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE; + virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, + const SkPaint&) SK_OVERRIDE; + virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[], + const SkPaint&) SK_OVERRIDE; + virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], + SkScalar constY, const SkPaint&) SK_OVERRIDE; + virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, + const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE; + virtual void onPushCull(const SkRect& cullRect) SK_OVERRIDE; + virtual void onPopCull() SK_OVERRIDE; - virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE; + virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE; + virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE; + virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE; + virtual void onClipRegion(const SkRegion& region, SkRegion::Op) SK_OVERRIDE; - virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE; + virtual void onDrawPicture(const SkPicture* picture) SK_OVERRIDE; - static const int kVizImageHeight = 256; - static const int kVizImageWidth = 256; + void markActiveCommands(int index); private: SkTDArray<SkDrawCommand*> fCommandVector; + SkPicture* fPicture; int fWidth; int fHeight; bool fFilter; + bool fMegaVizMode; int fIndex; SkMatrix fUserMatrix; SkMatrix fMatrix; SkIRect fClip; + SkString fClipStackData; + bool fCalledAddStackData; + SkPath fSaveDevPath; + bool fOverdrawViz; SkDrawFilter* fOverdrawFilter; @@ -258,6 +290,18 @@ private: int fOutstandingSaveCount; /** + The active saveLayer commands at a given point in the renderering. + Only used when "mega" visualization is enabled. + */ + SkTDArray<SkDrawCommand*> fActiveLayers; + + /** + The active cull commands at a given point in the rendering. + Only used when "mega" visualization is enabled. + */ + SkTDArray<SkDrawCommand*> fActiveCulls; + + /** Adds the command to the classes vector of commands. @param command The draw command for execution */ @@ -269,6 +313,23 @@ private: */ void applyUserTransform(SkCanvas* canvas); + size_t getOpID() const { + if (NULL != fPicture) { + return fPicture->EXPERIMENTAL_curOpID(); + } + return 0; + } + + void resetClipStackData() { fClipStackData.reset(); fCalledAddStackData = false; } + + void addClipStackData(const SkPath& devPath, const SkPath& operand, SkRegion::Op elementOp); + void addPathData(const SkPath& path, const char* pathName); + bool lastClipStackData(const SkPath& devPath); + void outputConicPoints(const SkPoint* pts, SkScalar weight); + void outputPoints(const SkPoint* pts, int count); + void outputPointsCommon(const SkPoint* pts, int count); + void outputScalar(SkScalar num); + typedef SkCanvas INHERITED; }; diff --git a/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.cpp b/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.cpp index db041cdce6c..7c73cec786c 100644 --- a/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.cpp +++ b/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.cpp @@ -14,10 +14,12 @@ SkDrawCommand::SkDrawCommand(DrawType type) : fDrawType(type) + , fOffset(0) , fVisible(true) { } SkDrawCommand::SkDrawCommand() { + fOffset = 0; fVisible = true; } @@ -64,6 +66,9 @@ const char* SkDrawCommand::GetCommandString(DrawType type) { case BEGIN_COMMENT_GROUP: return "BeginCommentGroup"; case COMMENT: return "Comment"; case END_COMMENT_GROUP: return "EndCommentGroup"; + case DRAW_DRRECT: return "Draw DRRect"; + case PUSH_CULL: return "PushCull"; + case POP_CULL: return "PopCull"; default: SkDebugf("DrawType error 0x%08x\n", type); SkASSERT(0); @@ -77,9 +82,8 @@ SkString SkDrawCommand::toString() { return SkString(GetCommandString(fDrawType)); } -SkClearCommand::SkClearCommand(SkColor color) { +SkClearCommand::SkClearCommand(SkColor color) : INHERITED(DRAW_CLEAR) { fColor = color; - fDrawType = DRAW_CLEAR; fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); } @@ -170,14 +174,30 @@ void render_rrect(SkCanvas* canvas, const SkRRect& rrect) { canvas->restore(); } +void render_drrect(SkCanvas* canvas, const SkRRect& outer, const SkRRect& inner) { + canvas->clear(0xFFFFFFFF); + canvas->save(); + + const SkRect& bounds = outer.getBounds(); + + xlate_and_scale_to_bounds(canvas, bounds); + + SkPaint p; + p.setColor(SK_ColorBLACK); + p.setStyle(SkPaint::kStroke_Style); + + canvas->drawDRRect(outer, inner, p); + canvas->restore(); +} + }; -SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA) { +SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA) + : INHERITED(CLIP_PATH) { fPath = path; fOp = op; fDoAA = doAA; - fDrawType = CLIP_PATH; fInfo.push(SkObjectParser::PathToString(path)); fInfo.push(SkObjectParser::RegionOpToString(op)); @@ -193,10 +213,10 @@ bool SkClipPathCommand::render(SkCanvas* canvas) const { return true; } -SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op) { +SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op) + : INHERITED(CLIP_REGION) { fRegion = region; fOp = op; - fDrawType = CLIP_REGION; fInfo.push(SkObjectParser::RegionToString(region)); fInfo.push(SkObjectParser::RegionOpToString(op)); @@ -206,11 +226,11 @@ void SkClipRegionCommand::execute(SkCanvas* canvas) { canvas->clipRegion(fRegion, fOp); } -SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA) { +SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA) + : INHERITED(CLIP_RECT) { fRect = rect; fOp = op; fDoAA = doAA; - fDrawType = CLIP_RECT; fInfo.push(SkObjectParser::RectToString(rect)); fInfo.push(SkObjectParser::RegionOpToString(op)); @@ -221,11 +241,11 @@ void SkClipRectCommand::execute(SkCanvas* canvas) { canvas->clipRect(fRect, fOp, fDoAA); } -SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA) { +SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA) + : INHERITED(CLIP_RRECT) { fRRect = rrect; fOp = op; fDoAA = doAA; - fDrawType = CLIP_RRECT; fInfo.push(SkObjectParser::RRectToString(rrect)); fInfo.push(SkObjectParser::RegionOpToString(op)); @@ -241,9 +261,9 @@ bool SkClipRRectCommand::render(SkCanvas* canvas) const { return true; } -SkConcatCommand::SkConcatCommand(const SkMatrix& matrix) { +SkConcatCommand::SkConcatCommand(const SkMatrix& matrix) + : INHERITED(CONCAT) { fMatrix = matrix; - fDrawType = CONCAT; fInfo.push(SkObjectParser::MatrixToString(matrix)); } @@ -253,7 +273,8 @@ void SkConcatCommand::execute(SkCanvas* canvas) { } SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, - const SkPaint* paint) { + const SkPaint* paint) + : INHERITED(DRAW_BITMAP) { fBitmap = bitmap; fLeft = left; fTop = top; @@ -263,7 +284,6 @@ SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, } else { fPaintPtr = NULL; } - fDrawType = DRAW_BITMAP; fInfo.push(SkObjectParser::BitmapToString(bitmap)); fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: ")); @@ -284,7 +304,8 @@ bool SkDrawBitmapCommand::render(SkCanvas* canvas) const { SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix, - const SkPaint* paint) { + const SkPaint* paint) + : INHERITED(DRAW_BITMAP_MATRIX) { fBitmap = bitmap; fMatrix = matrix; if (NULL != paint) { @@ -293,7 +314,6 @@ SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, } else { fPaintPtr = NULL; } - fDrawType = DRAW_BITMAP_MATRIX; fInfo.push(SkObjectParser::BitmapToString(bitmap)); fInfo.push(SkObjectParser::MatrixToString(matrix)); @@ -312,7 +332,8 @@ bool SkDrawBitmapMatrixCommand::render(SkCanvas* canvas) const { } SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, - const SkRect& dst, const SkPaint* paint) { + const SkRect& dst, const SkPaint* paint) + : INHERITED(DRAW_BITMAP_NINE) { fBitmap = bitmap; fCenter = center; fDst = dst; @@ -322,7 +343,6 @@ SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const S } else { fPaintPtr = NULL; } - fDrawType = DRAW_BITMAP_NINE; fInfo.push(SkObjectParser::BitmapToString(bitmap)); fInfo.push(SkObjectParser::IRectToString(center)); @@ -343,7 +363,8 @@ bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const { SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, const SkPaint* paint, - SkCanvas::DrawBitmapRectFlags flags) { + SkCanvas::DrawBitmapRectFlags flags) + : INHERITED(DRAW_BITMAP_RECT_TO_RECT) { fBitmap = bitmap; if (NULL != src) { fSrc = *src; @@ -360,8 +381,6 @@ SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const S } fFlags = flags; - fDrawType = DRAW_BITMAP_RECT_TO_RECT; - fInfo.push(SkObjectParser::BitmapToString(bitmap)); if (NULL != src) { fInfo.push(SkObjectParser::RectToString(*src, "Src: ")); @@ -382,11 +401,11 @@ bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const { return true; } -SkDrawDataCommand::SkDrawDataCommand(const void* data, size_t length) { +SkDrawDataCommand::SkDrawDataCommand(const void* data, size_t length) + : INHERITED(DRAW_DATA) { fData = new char[length]; memcpy(fData, data, length); fLength = length; - fDrawType = DRAW_DATA; // TODO: add display of actual data? SkString* str = new SkString; @@ -415,13 +434,14 @@ SkCommentCommand::SkCommentCommand(const char* kywd, const char* value) fInfo.push(temp); } -SkEndCommentGroupCommand::SkEndCommentGroupCommand() : INHERITED(END_COMMENT_GROUP) { +SkEndCommentGroupCommand::SkEndCommentGroupCommand() + : INHERITED(END_COMMENT_GROUP) { } -SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) { +SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) + : INHERITED(DRAW_OVAL) { fOval = oval; fPaint = paint; - fDrawType = DRAW_OVAL; fInfo.push(SkObjectParser::RectToString(oval)); fInfo.push(SkObjectParser::PaintToString(paint)); @@ -447,9 +467,9 @@ bool SkDrawOvalCommand::render(SkCanvas* canvas) const { return true; } -SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) { +SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) + : INHERITED(DRAW_PAINT) { fPaint = paint; - fDrawType = DRAW_PAINT; fInfo.push(SkObjectParser::PaintToString(paint)); } @@ -464,10 +484,10 @@ bool SkDrawPaintCommand::render(SkCanvas* canvas) const { return true; } -SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) { +SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) + : INHERITED(DRAW_PATH) { fPath = path; fPaint = paint; - fDrawType = DRAW_PATH; fInfo.push(SkObjectParser::PathToString(path)); fInfo.push(SkObjectParser::PaintToString(paint)); @@ -482,11 +502,11 @@ bool SkDrawPathCommand::render(SkCanvas* canvas) const { return true; } -SkDrawPictureCommand::SkDrawPictureCommand(SkPicture& picture) : - fPicture(picture) { - fDrawType = DRAW_PICTURE; +SkDrawPictureCommand::SkDrawPictureCommand(const SkPicture* picture) + : INHERITED(DRAW_PICTURE) + , fPicture(SkRef(picture)) { SkString* temp = new SkString; - temp->appendf("SkPicture: W: %d H: %d", picture.width(), picture.height()); + temp->appendf("SkPicture: W: %d H: %d", picture->width(), picture->height()); fInfo.push(temp); } @@ -498,11 +518,11 @@ bool SkDrawPictureCommand::render(SkCanvas* canvas) const { canvas->clear(0xFFFFFFFF); canvas->save(); - SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture.width()), - SkIntToScalar(fPicture.height())); + SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture->width()), + SkIntToScalar(fPicture->height())); xlate_and_scale_to_bounds(canvas, bounds); - canvas->drawPicture(const_cast<SkPicture&>(fPicture)); + canvas->drawPicture(fPicture.get()); canvas->restore(); @@ -510,13 +530,13 @@ bool SkDrawPictureCommand::render(SkCanvas* canvas) const { } SkDrawPointsCommand::SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, - const SkPoint pts[], const SkPaint& paint) { + const SkPoint pts[], const SkPaint& paint) + : INHERITED(DRAW_POINTS) { fMode = mode; fCount = count; fPts = new SkPoint[count]; memcpy(fPts, pts, count * sizeof(SkPoint)); fPaint = paint; - fDrawType = DRAW_POINTS; fInfo.push(SkObjectParser::PointsToString(pts, count)); fInfo.push(SkObjectParser::ScalarToString(SkIntToScalar((unsigned int)count), @@ -553,7 +573,8 @@ bool SkDrawPointsCommand::render(SkCanvas* canvas) const { } SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength, - const SkPoint pos[], const SkPaint& paint) { + const SkPoint pos[], const SkPaint& paint) + : INHERITED(DRAW_POS_TEXT) { size_t numPts = paint.countText(text, byteLength); fText = new char[byteLength]; @@ -564,7 +585,6 @@ SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength, memcpy(fPos, pos, numPts * sizeof(SkPoint)); fPaint = paint; - fDrawType = DRAW_POS_TEXT; fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); // TODO(chudy): Test that this works. @@ -579,7 +599,8 @@ void SkDrawPosTextCommand::execute(SkCanvas* canvas) { SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, - const SkPaint& paint) { + const SkPaint& paint) + : INHERITED(DRAW_POS_TEXT_H) { size_t numPts = paint.countText(text, byteLength); fText = new char[byteLength]; @@ -591,7 +612,6 @@ SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength fConstY = constY; fPaint = paint; - fDrawType = DRAW_POS_TEXT_H; fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); fInfo.push(SkObjectParser::ScalarToString(xpos[0], "XPOS: ")); @@ -603,10 +623,10 @@ void SkDrawPosTextHCommand::execute(SkCanvas* canvas) { canvas->drawPosTextH(fText, fByteLength, fXpos, fConstY, fPaint); } -SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint) { +SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint) + : INHERITED(DRAW_RECT) { fRect = rect; fPaint = paint; - fDrawType = DRAW_RECT; fInfo.push(SkObjectParser::RectToString(rect)); fInfo.push(SkObjectParser::PaintToString(paint)); @@ -616,10 +636,10 @@ void SkDrawRectCommand::execute(SkCanvas* canvas) { canvas->drawRect(fRect, fPaint); } -SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint) { +SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint) + : INHERITED(DRAW_RRECT) { fRRect = rrect; fPaint = paint; - fDrawType = DRAW_RRECT; fInfo.push(SkObjectParser::RRectToString(rrect)); fInfo.push(SkObjectParser::PaintToString(paint)); @@ -634,8 +654,31 @@ bool SkDrawRRectCommand::render(SkCanvas* canvas) const { return true; } +SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer, + const SkRRect& inner, + const SkPaint& paint) + : INHERITED(DRAW_DRRECT) { + fOuter = outer; + fInner = inner; + fPaint = paint; + + fInfo.push(SkObjectParser::RRectToString(outer)); + fInfo.push(SkObjectParser::RRectToString(inner)); + fInfo.push(SkObjectParser::PaintToString(paint)); +} + +void SkDrawDRRectCommand::execute(SkCanvas* canvas) { + canvas->drawDRRect(fOuter, fInner, fPaint); +} + +bool SkDrawDRRectCommand::render(SkCanvas* canvas) const { + render_drrect(canvas, fOuter, fInner); + return true; +} + SkDrawSpriteCommand::SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, - const SkPaint* paint) { + const SkPaint* paint) + : INHERITED(DRAW_SPRITE) { fBitmap = bitmap; fLeft = left; fTop = top; @@ -645,7 +688,6 @@ SkDrawSpriteCommand::SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int t } else { fPaintPtr = NULL; } - fDrawType = DRAW_SPRITE; fInfo.push(SkObjectParser::BitmapToString(bitmap)); fInfo.push(SkObjectParser::IntToString(left, "Left: ")); @@ -665,14 +707,14 @@ bool SkDrawSpriteCommand::render(SkCanvas* canvas) const { } SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, - const SkPaint& paint) { + const SkPaint& paint) + : INHERITED(DRAW_TEXT) { fText = new char[byteLength]; memcpy(fText, text, byteLength); fByteLength = byteLength; fX = x; fY = y; fPaint = paint; - fDrawType = DRAW_TEXT; fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); fInfo.push(SkObjectParser::ScalarToString(x, "SkScalar x: ")); @@ -686,7 +728,8 @@ void SkDrawTextCommand::execute(SkCanvas* canvas) { SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path, const SkMatrix* matrix, - const SkPaint& paint) { + const SkPaint& paint) + : INHERITED(DRAW_TEXT_ON_PATH) { fText = new char[byteLength]; memcpy(fText, text, byteLength); fByteLength = byteLength; @@ -697,7 +740,6 @@ SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLe fMatrix.setIdentity(); } fPaint = paint; - fDrawType = DRAW_TEXT_ON_PATH; fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); fInfo.push(SkObjectParser::PathToString(path)); @@ -717,7 +759,8 @@ SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int ver const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode* xfermode, const uint16_t indices[], int indexCount, - const SkPaint& paint) { + const SkPaint& paint) + : INHERITED(DRAW_VERTICES) { fVmode = vmode; fVertexCount = vertexCount; @@ -753,7 +796,6 @@ SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int ver fIndexCount = indexCount; fPaint = paint; - fDrawType = DRAW_VERTICES; // TODO(chudy) fInfo.push(SkObjectParser::CustomTextToString("To be implemented.")); @@ -774,8 +816,8 @@ void SkDrawVerticesCommand::execute(SkCanvas* canvas) { fIndexCount, fPaint); } -SkRestoreCommand::SkRestoreCommand() { - fDrawType = RESTORE; +SkRestoreCommand::SkRestoreCommand() + : INHERITED(RESTORE) { fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); } @@ -787,9 +829,9 @@ void SkRestoreCommand::trackSaveState(int* state) { (*state)--; } -SkRotateCommand::SkRotateCommand(SkScalar degrees) { +SkRotateCommand::SkRotateCommand(SkScalar degrees) + : INHERITED(ROTATE) { fDegrees = degrees; - fDrawType = ROTATE; fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: ")); } @@ -798,9 +840,9 @@ void SkRotateCommand::execute(SkCanvas* canvas) { canvas->rotate(fDegrees); } -SkSaveCommand::SkSaveCommand(SkCanvas::SaveFlags flags) { +SkSaveCommand::SkSaveCommand(SkCanvas::SaveFlags flags) + : INHERITED(SAVE) { fFlags = flags; - fDrawType = SAVE; fInfo.push(SkObjectParser::SaveFlagsToString(flags)); } @@ -813,7 +855,8 @@ void SkSaveCommand::trackSaveState(int* state) { } SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, - SkCanvas::SaveFlags flags) { + SkCanvas::SaveFlags flags) + : INHERITED(SAVE_LAYER) { if (NULL != bounds) { fBounds = *bounds; } else { @@ -827,7 +870,6 @@ SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* pain fPaintPtr = NULL; } fFlags = flags; - fDrawType = SAVE_LAYER; if (NULL != bounds) { fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: ")); @@ -844,14 +886,18 @@ void SkSaveLayerCommand::execute(SkCanvas* canvas) { fFlags); } +void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) { + canvas->save(); +} + void SkSaveLayerCommand::trackSaveState(int* state) { (*state)++; } -SkScaleCommand::SkScaleCommand(SkScalar sx, SkScalar sy) { +SkScaleCommand::SkScaleCommand(SkScalar sx, SkScalar sy) + : INHERITED(SCALE) { fSx = sx; fSy = sy; - fDrawType = SCALE; fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); @@ -861,9 +907,9 @@ void SkScaleCommand::execute(SkCanvas* canvas) { canvas->scale(fSx, fSy); } -SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) { +SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) + : INHERITED(SET_MATRIX) { fMatrix = matrix; - fDrawType = SET_MATRIX; fInfo.push(SkObjectParser::MatrixToString(matrix)); } @@ -872,10 +918,10 @@ void SkSetMatrixCommand::execute(SkCanvas* canvas) { canvas->setMatrix(fMatrix); } -SkSkewCommand::SkSkewCommand(SkScalar sx, SkScalar sy) { +SkSkewCommand::SkSkewCommand(SkScalar sx, SkScalar sy) + : INHERITED(SKEW) { fSx = sx; fSy = sy; - fDrawType = SKEW; fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); @@ -885,10 +931,10 @@ void SkSkewCommand::execute(SkCanvas* canvas) { canvas->skew(fSx, fSy); } -SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) { +SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) + : INHERITED(TRANSLATE) { fDx = dx; fDy = dy; - fDrawType = TRANSLATE; fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: ")); fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: ")); @@ -897,3 +943,28 @@ SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) { void SkTranslateCommand::execute(SkCanvas* canvas) { canvas->translate(fDx, fDy); } + +SkPushCullCommand::SkPushCullCommand(const SkRect& cullRect) + : INHERITED(PUSH_CULL) + , fCullRect(cullRect) { + fInfo.push(SkObjectParser::RectToString(cullRect)); +} + +void SkPushCullCommand::execute(SkCanvas* canvas) { + canvas->pushCull(fCullRect); +} + +void SkPushCullCommand::vizExecute(SkCanvas* canvas) { + canvas->pushCull(fCullRect); + + SkPaint p; + p.setColor(SK_ColorCYAN); + p.setStyle(SkPaint::kStroke_Style); + canvas->drawRect(fCullRect, p); +} + +SkPopCullCommand::SkPopCullCommand() : INHERITED(POP_CULL) { } + +void SkPopCullCommand::execute(SkCanvas* canvas) { + canvas->popCull(); +} diff --git a/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.h b/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.h index b78dc9c3c4d..a0bfb2ddca5 100644 --- a/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.h +++ b/chromium/third_party/skia/src/utils/debugger/SkDrawCommand.h @@ -23,6 +23,9 @@ public: virtual SkString toString(); + void setOffset(size_t offset) { fOffset = offset; } + virtual size_t offset() { return fOffset; } + virtual const char* toCString() { return GetCommandString(fDrawType); } @@ -36,10 +39,34 @@ public: } SkTDArray<SkString*>* Info() {return &fInfo; }; - virtual void execute(SkCanvas* canvas)=0; + virtual void execute(SkCanvas* canvas) = 0; + virtual void vizExecute(SkCanvas* canvas) { }; /** Does nothing by default, but used by save() and restore()-type - subclassse to track unresolved save() calls. */ + subclasses to track unresolved save() calls. */ virtual void trackSaveState(int* state) { }; + + // The next "active" system is only used by save, saveLayer, restore, + // pushCull and popCull. It is used in two ways: + // To determine which saveLayers are currently active (at a + // given point in the rendering). + // saves just return a kPushLayer action but don't track active state + // restores just return a kPopLayer action + // saveLayers return kPushLayer but also track the active state + // To determine which culls are currently active (at a given point) + // in the rendering). + // pushCulls return a kPushCull action + // popCulls return a kPopCull action + enum Action { + kNone_Action, + kPopLayer_Action, + kPushLayer_Action, + kPopCull_Action, + kPushCull_Action + }; + virtual Action action() const { return kNone_Action; } + virtual void setActive(bool active) {} + virtual bool active() const { return false; } + DrawType getType() { return fDrawType; }; virtual bool render(SkCanvas* canvas) const { return false; } @@ -47,11 +74,12 @@ public: static const char* GetCommandString(DrawType type); protected: - DrawType fDrawType; SkTDArray<SkString*> fInfo; private: - bool fVisible; + DrawType fDrawType; + size_t fOffset; + bool fVisible; }; class SkRestoreCommand : public SkDrawCommand { @@ -59,6 +87,7 @@ public: SkRestoreCommand(); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual void trackSaveState(int* state) SK_OVERRIDE; + virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; } private: typedef SkDrawCommand INHERITED; @@ -146,7 +175,7 @@ private: class SkDrawBitmapCommand : public SkDrawCommand { public: SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, - const SkPaint* paint); + const SkPaint* paint); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; private: @@ -162,7 +191,7 @@ private: class SkDrawBitmapMatrixCommand : public SkDrawCommand { public: SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix, - const SkPaint* paint); + const SkPaint* paint); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; private: @@ -177,7 +206,7 @@ private: class SkDrawBitmapNineCommand : public SkDrawCommand { public: SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, - const SkRect& dst, const SkPaint* paint); + const SkRect& dst, const SkPaint* paint); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; private: @@ -314,12 +343,12 @@ private: class SkDrawPictureCommand : public SkDrawCommand { public: - SkDrawPictureCommand(SkPicture& picture); + SkDrawPictureCommand(const SkPicture* picture); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; private: - SkPicture fPicture; + SkAutoTUnref<const SkPicture> fPicture; typedef SkDrawCommand INHERITED; }; @@ -327,7 +356,7 @@ private: class SkDrawPointsCommand : public SkDrawCommand { public: SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[], - const SkPaint& paint); + const SkPaint& paint); virtual ~SkDrawPointsCommand() { delete [] fPts; } virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; @@ -343,7 +372,7 @@ private: class SkDrawTextCommand : public SkDrawCommand { public: SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, - const SkPaint& paint); + const SkPaint& paint); virtual ~SkDrawTextCommand() { delete [] fText; } virtual void execute(SkCanvas* canvas) SK_OVERRIDE; private: @@ -429,6 +458,20 @@ private: typedef SkDrawCommand INHERITED; }; +class SkDrawDRRectCommand : public SkDrawCommand { +public: + SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, + const SkPaint& paint); + virtual void execute(SkCanvas* canvas) SK_OVERRIDE; + virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; +private: + SkRRect fOuter; + SkRRect fInner; + SkPaint fPaint; + + typedef SkDrawCommand INHERITED; +}; + class SkDrawSpriteCommand : public SkDrawCommand { public: SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint); @@ -482,6 +525,7 @@ public: SkSaveCommand(SkCanvas::SaveFlags flags); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; virtual void trackSaveState(int* state) SK_OVERRIDE; + virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; } private: SkCanvas::SaveFlags fFlags; @@ -493,7 +537,11 @@ public: SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, SkCanvas::SaveFlags flags); virtual void execute(SkCanvas* canvas) SK_OVERRIDE; + virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE; virtual void trackSaveState(int* state) SK_OVERRIDE; + virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; } + virtual void setActive(bool active) SK_OVERRIDE { fActive = active; } + virtual bool active() const SK_OVERRIDE { return fActive; } const SkPaint* paint() const { return fPaintPtr; } @@ -503,6 +551,8 @@ private: SkPaint* fPaintPtr; SkCanvas::SaveFlags fFlags; + bool fActive; + typedef SkDrawCommand INHERITED; }; @@ -557,4 +607,28 @@ private: typedef SkDrawCommand INHERITED; }; +class SkPushCullCommand : public SkDrawCommand { +public: + SkPushCullCommand(const SkRect&); + virtual void execute(SkCanvas*) SK_OVERRIDE; + virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE; + virtual Action action() const { return kPushCull_Action; } + virtual void setActive(bool active) { fActive = active; } + virtual bool active() const { return fActive; } +private: + SkRect fCullRect; + bool fActive; + + typedef SkDrawCommand INHERITED; +}; + +class SkPopCullCommand : public SkDrawCommand { +public: + SkPopCullCommand(); + virtual void execute(SkCanvas* canvas) SK_OVERRIDE; + virtual Action action() const { return kPopCull_Action; } +private: + typedef SkDrawCommand INHERITED; +}; + #endif diff --git a/chromium/third_party/skia/src/utils/debugger/SkObjectParser.cpp b/chromium/third_party/skia/src/utils/debugger/SkObjectParser.cpp index ebbd40018e7..b932036a894 100644 --- a/chromium/third_party/skia/src/utils/debugger/SkObjectParser.cpp +++ b/chromium/third_party/skia/src/utils/debugger/SkObjectParser.cpp @@ -25,13 +25,13 @@ SkString* SkObjectParser::BitmapToString(const SkBitmap& bitmap) { mBitmap->append(" H: "); mBitmap->appendS32(bitmap.height()); - const char* gConfigStrings[] = { - "None", "A8", "Index8", "RGB565", "ARGB4444", "ARGB8888" + const char* gColorTypeStrings[] = { + "None", "A8", "565", "4444", "RGBA", "BGRA", "Index8" }; - SkASSERT(SkBitmap::kConfigCount == SK_ARRAY_COUNT(gConfigStrings)); + SkASSERT(kLastEnum_SkColorType + 1 == SK_ARRAY_COUNT(gColorTypeStrings)); - mBitmap->append(" Config: "); - mBitmap->append(gConfigStrings[bitmap.config()]); + mBitmap->append(" ColorType: "); + mBitmap->append(gColorTypeStrings[bitmap.colorType()]); if (bitmap.isOpaque()) { mBitmap->append(" opaque"); @@ -94,7 +94,7 @@ SkString* SkObjectParser::IRectToString(const SkIRect& rect) { SkString* SkObjectParser::MatrixToString(const SkMatrix& matrix) { SkString* str = new SkString("SkMatrix: "); -#ifdef SK_DEVELOPER +#ifndef SK_IGNORE_TO_STRING matrix.toString(str); #endif return str; @@ -102,7 +102,7 @@ SkString* SkObjectParser::MatrixToString(const SkMatrix& matrix) { SkString* SkObjectParser::PaintToString(const SkPaint& paint) { SkString* str = new SkString; -#ifdef SK_DEVELOPER +#ifndef SK_IGNORE_TO_STRING paint.toString(str); #endif return str; @@ -241,6 +241,8 @@ SkString* SkObjectParser::RRectToString(const SkRRect& rrect, const char* title) mRRect->append("oval"); } else if (rrect.isSimple()) { mRRect->append("simple"); + } else if (rrect.isNinePatch()) { + mRRect->append("nine-patch"); } else { SkASSERT(rrect.isComplex()); mRRect->append("complex"); diff --git a/chromium/third_party/skia/src/utils/debugger/SkObjectParser.h b/chromium/third_party/skia/src/utils/debugger/SkObjectParser.h index 911b7789215..da842653ffc 100644 --- a/chromium/third_party/skia/src/utils/debugger/SkObjectParser.h +++ b/chromium/third_party/skia/src/utils/debugger/SkObjectParser.h @@ -20,7 +20,7 @@ class SkObjectParser { public: /** - Returns a string about a bitmaps bounds and config. + Returns a string about a bitmaps bounds and colortype. @param bitmap SkBitmap */ static SkString* BitmapToString(const SkBitmap& bitmap); |