The Tor Browser: gfx/skia/trunk/src/utils/debugger/SkDrawCommand.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/utils/debugger/SkDrawCommand.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/utils/debugger/SkDrawCommand.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * 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 "SkDrawCommand.h"
 #include "SkObjectParser.h"
 // TODO(chudy): Refactor into non subclass model.
 SkDrawCommand::SkDrawCommand(DrawType type)
     : fDrawType(type)
     , fVisible(true) {
 }
 SkDrawCommand::SkDrawCommand() {
     fVisible = true;
 }
 SkDrawCommand::~SkDrawCommand() {
     fInfo.deleteAll();
 }
 const char* SkDrawCommand::GetCommandString(DrawType type) {
     switch (type) {
         case UNUSED: SkDEBUGFAIL("DrawType UNUSED\n"); break;
         case DRAW_CLEAR: return "Clear";
         case CLIP_PATH: return "Clip Path";
         case CLIP_REGION: return "Clip Region";
         case CLIP_RECT: return "Clip Rect";
         case CLIP_RRECT: return "Clip RRect";
         case CONCAT: return "Concat";
         case DRAW_BITMAP: return "Draw Bitmap";
         case DRAW_BITMAP_MATRIX: return "Draw Bitmap Matrix";
         case DRAW_BITMAP_NINE: return "Draw Bitmap Nine";
         case DRAW_BITMAP_RECT_TO_RECT: return "Draw Bitmap Rect";
         case DRAW_DATA: return "Draw Data";
         case DRAW_OVAL: return "Draw Oval";
         case DRAW_PAINT: return "Draw Paint";
         case DRAW_PATH: return "Draw Path";
         case DRAW_PICTURE: return "Draw Picture";
         case DRAW_POINTS: return "Draw Points";
         case DRAW_POS_TEXT: return "Draw Pos Text";
         case DRAW_POS_TEXT_H: return "Draw Pos Text H";
         case DRAW_RECT: return "Draw Rect";
         case DRAW_RRECT: return "Draw RRect";
         case DRAW_SPRITE: return "Draw Sprite";
         case DRAW_TEXT: return "Draw Text";
         case DRAW_TEXT_ON_PATH: return "Draw Text On Path";
         case DRAW_VERTICES: return "Draw Vertices";
         case RESTORE: return "Restore";
         case ROTATE: return "Rotate";
         case SAVE: return "Save";
         case SAVE_LAYER: return "Save Layer";
         case SCALE: return "Scale";
         case SET_MATRIX: return "Set Matrix";
         case SKEW: return "Skew";
         case TRANSLATE: return "Translate";
         case NOOP: return "NoOp";
         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);
             break;
     }
     SkDEBUGFAIL("DrawType UNUSED\n");
     return NULL;
 }
 SkString SkDrawCommand::toString() {
     return SkString(GetCommandString(fDrawType));
 }
 SkClearCommand::SkClearCommand(SkColor color) {
     fColor = color;
     fDrawType = DRAW_CLEAR;
     fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 void SkClearCommand::execute(SkCanvas* canvas) {
     canvas->clear(fColor);
 }
 namespace {
 void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
     const SkISize& size = canvas->getDeviceSize();
     static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
     canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f);
     if (bounds.width() > bounds.height()) {
         canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.width()),
                       SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.width()));
     } else {
         canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.height()),
                       SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.height()));
     }
     canvas->translate(-bounds.centerX(), -bounds.centerY());
 }
 void render_path(SkCanvas* canvas, const SkPath& path) {
     canvas->clear(0xFFFFFFFF);
     canvas->save();
     const SkRect& bounds = path.getBounds();
     xlate_and_scale_to_bounds(canvas, bounds);
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
     canvas->drawPath(path, p);
     canvas->restore();
 }
 void render_bitmap(SkCanvas* canvas, const SkBitmap& input, const SkRect* srcRect = NULL) {
     const SkISize& size = canvas->getDeviceSize();
     SkScalar xScale = SkIntToScalar(size.fWidth-2) / input.width();
     SkScalar yScale = SkIntToScalar(size.fHeight-2) / input.height();
     if (input.width() > input.height()) {
         yScale *= input.height() / (float) input.width();
     } else {
         xScale *= input.width() / (float) input.height();
     }
     SkRect dst = SkRect::MakeXYWH(SK_Scalar1, SK_Scalar1,
                                   xScale * input.width(),
                                   yScale * input.height());
     canvas->clear(0xFFFFFFFF);
     canvas->drawBitmapRect(input, NULL, dst);
     if (NULL != srcRect) {
         SkRect r = SkRect::MakeLTRB(srcRect->fLeft * xScale + SK_Scalar1,
                                     srcRect->fTop * yScale + SK_Scalar1,
                                     srcRect->fRight * xScale + SK_Scalar1,
                                     srcRect->fBottom * yScale + SK_Scalar1);
         SkPaint p;
         p.setColor(SK_ColorRED);
         p.setStyle(SkPaint::kStroke_Style);
         canvas->drawRect(r, p);
     }
 }
 void render_rrect(SkCanvas* canvas, const SkRRect& rrect) {
     canvas->clear(0xFFFFFFFF);
     canvas->save();
     const SkRect& bounds = rrect.getBounds();
     xlate_and_scale_to_bounds(canvas, bounds);
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
     canvas->drawRRect(rrect, p);
     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) {
     fPath = path;
     fOp = op;
     fDoAA = doAA;
     fDrawType = CLIP_PATH;
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 void SkClipPathCommand::execute(SkCanvas* canvas) {
     canvas->clipPath(fPath, fOp, fDoAA);
 }
 bool SkClipPathCommand::render(SkCanvas* canvas) const {
     render_path(canvas, fPath);
     return true;
 }
 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op) {
     fRegion = region;
     fOp = op;
     fDrawType = CLIP_REGION;
     fInfo.push(SkObjectParser::RegionToString(region));
     fInfo.push(SkObjectParser::RegionOpToString(op));
 }
 void SkClipRegionCommand::execute(SkCanvas* canvas) {
     canvas->clipRegion(fRegion, fOp);
 }
 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA) {
     fRect = rect;
     fOp = op;
     fDoAA = doAA;
     fDrawType = CLIP_RECT;
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 void SkClipRectCommand::execute(SkCanvas* canvas) {
     canvas->clipRect(fRect, fOp, fDoAA);
 }
 SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
     fRRect = rrect;
     fOp = op;
     fDoAA = doAA;
     fDrawType = CLIP_RRECT;
     fInfo.push(SkObjectParser::RRectToString(rrect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 void SkClipRRectCommand::execute(SkCanvas* canvas) {
     canvas->clipRRect(fRRect, fOp, fDoAA);
 }
 bool SkClipRRectCommand::render(SkCanvas* canvas) const {
     render_rrect(canvas, fRRect);
     return true;
 }
 SkConcatCommand::SkConcatCommand(const SkMatrix& matrix) {
     fMatrix = matrix;
     fDrawType = CONCAT;
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 void SkConcatCommand::execute(SkCanvas* canvas) {
     canvas->concat(fMatrix);
 }
 SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                        const SkPaint* paint) {
     fBitmap = bitmap;
     fLeft = left;
     fTop = top;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP;
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: "));
     fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 void SkDrawBitmapCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
 }
 bool SkDrawBitmapCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap,
                                                      const SkMatrix& matrix,
                                                      const SkPaint* paint) {
     fBitmap = bitmap;
     fMatrix = matrix;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP_MATRIX;
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::MatrixToString(matrix));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 void SkDrawBitmapMatrixCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr);
 }
 bool SkDrawBitmapMatrixCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
                                                  const SkRect& dst, const SkPaint* paint) {
     fBitmap = bitmap;
     fCenter = center;
     fDst = dst;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_BITMAP_NINE;
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::IRectToString(center));
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
 }
 bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
                                                  const SkRect& dst, const SkPaint* paint,
                                                  SkCanvas::DrawBitmapRectFlags flags) {
     fBitmap = bitmap;
     if (NULL != src) {
         fSrc = *src;
     } else {
         fSrc.setEmpty();
     }
     fDst = dst;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fFlags = flags;
     fDrawType = DRAW_BITMAP_RECT_TO_RECT;
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     if (NULL != src) {
         fInfo.push(SkObjectParser::RectToString(*src, "Src: "));
     }
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
     fInfo.push(SkObjectParser::IntToString(fFlags, "Flags: "));
 }
 void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr, fFlags);
 }
 bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap, this->srcRect());
     return true;
 }
 SkDrawDataCommand::SkDrawDataCommand(const void* data, size_t length) {
     fData = new char[length];
     memcpy(fData, data, length);
     fLength = length;
     fDrawType = DRAW_DATA;
     // TODO: add display of actual data?
     SkString* str = new SkString;
     str->appendf("length: %d", (int) length);
     fInfo.push(str);
 }
 void SkDrawDataCommand::execute(SkCanvas* canvas) {
     canvas->drawData(fData, fLength);
 }
 SkBeginCommentGroupCommand::SkBeginCommentGroupCommand(const char* description)
     : INHERITED(BEGIN_COMMENT_GROUP)
     , fDescription(description) {
     SkString* temp = new SkString;
     temp->appendf("Description: %s", description);
     fInfo.push(temp);
 }
 SkCommentCommand::SkCommentCommand(const char* kywd, const char* value)
     : INHERITED(COMMENT)
     , fKywd(kywd)
     , fValue(value) {
     SkString* temp = new SkString;
     temp->appendf("%s: %s", kywd, value);
     fInfo.push(temp);
 }
 SkEndCommentGroupCommand::SkEndCommentGroupCommand() : INHERITED(END_COMMENT_GROUP) {
 }
 SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) {
     fOval = oval;
     fPaint = paint;
     fDrawType = DRAW_OVAL;
     fInfo.push(SkObjectParser::RectToString(oval));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawOvalCommand::execute(SkCanvas* canvas) {
     canvas->drawOval(fOval, fPaint);
 }
 bool SkDrawOvalCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->save();
     xlate_and_scale_to_bounds(canvas, fOval);
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
     canvas->drawOval(fOval, p);
     canvas->restore();
     return true;
 }
 SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) {
     fPaint = paint;
     fDrawType = DRAW_PAINT;
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawPaintCommand::execute(SkCanvas* canvas) {
     canvas->drawPaint(fPaint);
 }
 bool SkDrawPaintCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->drawPaint(fPaint);
     return true;
 }
 SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) {
     fPath = path;
     fPaint = paint;
     fDrawType = DRAW_PATH;
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawPathCommand::execute(SkCanvas* canvas) {
     canvas->drawPath(fPath, fPaint);
 }
 bool SkDrawPathCommand::render(SkCanvas* canvas) const {
     render_path(canvas, fPath);
     return true;
 }
 SkDrawPictureCommand::SkDrawPictureCommand(SkPicture& picture) :
     fPicture(picture) {
     fDrawType = DRAW_PICTURE;
     SkString* temp = new SkString;
     temp->appendf("SkPicture: W: %d H: %d", picture.width(), picture.height());
     fInfo.push(temp);
 }
 void SkDrawPictureCommand::execute(SkCanvas* canvas) {
     canvas->drawPicture(fPicture);
 }
 bool SkDrawPictureCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->save();
     SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture.width()),
                                    SkIntToScalar(fPicture.height()));
     xlate_and_scale_to_bounds(canvas, bounds);
     canvas->drawPicture(const_cast<SkPicture&>(fPicture));
     canvas->restore();
     return true;
 }
 SkDrawPointsCommand::SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count,
                                          const SkPoint pts[], const SkPaint& paint) {
     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),
                                               "Points: "));
     fInfo.push(SkObjectParser::PointModeToString(mode));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawPointsCommand::execute(SkCanvas* canvas) {
     canvas->drawPoints(fMode, fCount, fPts, fPaint);
 }
 bool SkDrawPointsCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->save();
     SkRect bounds;
     bounds.setEmpty();
     for (unsigned int i = 0; i < fCount; ++i) {
         bounds.growToInclude(fPts[i].fX, fPts[i].fY);
     }
     xlate_and_scale_to_bounds(canvas, bounds);
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
     canvas->drawPoints(fMode, fCount, fPts, p);
     canvas->restore();
     return true;
 }
 SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength,
                                            const SkPoint pos[], const SkPaint& paint) {
     size_t numPts = paint.countText(text, byteLength);
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fPos = new SkPoint[numPts];
     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.
     fInfo.push(SkObjectParser::PointsToString(pos, 1));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawPosTextCommand::execute(SkCanvas* canvas) {
     canvas->drawPosText(fText, fByteLength, fPos, fPaint);
 }
 SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength,
                                              const SkScalar xpos[], SkScalar constY,
                                              const SkPaint& paint) {
     size_t numPts = paint.countText(text, byteLength);
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fXpos = new SkScalar[numPts];
     memcpy(fXpos, xpos, numPts * sizeof(SkScalar));
     fConstY = constY;
     fPaint = paint;
     fDrawType = DRAW_POS_TEXT_H;
     fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
     fInfo.push(SkObjectParser::ScalarToString(xpos[0], "XPOS: "));
     fInfo.push(SkObjectParser::ScalarToString(constY, "SkScalar constY: "));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawPosTextHCommand::execute(SkCanvas* canvas) {
     canvas->drawPosTextH(fText, fByteLength, fXpos, fConstY, fPaint);
 }
 SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint) {
     fRect = rect;
     fPaint = paint;
     fDrawType = DRAW_RECT;
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawRectCommand::execute(SkCanvas* canvas) {
     canvas->drawRect(fRect, fPaint);
 }
 SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint) {
     fRRect = rrect;
     fPaint = paint;
     fDrawType = DRAW_RRECT;
     fInfo.push(SkObjectParser::RRectToString(rrect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawRRectCommand::execute(SkCanvas* canvas) {
     canvas->drawRRect(fRRect, fPaint);
 }
 bool SkDrawRRectCommand::render(SkCanvas* canvas) const {
     render_rrect(canvas, fRRect);
     return true;
 }
 SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer,
                                          const SkRRect& inner,
                                          const SkPaint& paint) {
     fOuter = outer;
     fInner = inner;
     fPaint = paint;
     fDrawType = DRAW_DRRECT;
     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) {
     fBitmap = bitmap;
     fLeft = left;
     fTop = top;
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fDrawType = DRAW_SPRITE;
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::IntToString(left, "Left: "));
     fInfo.push(SkObjectParser::IntToString(top, "Top: "));
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 void SkDrawSpriteCommand::execute(SkCanvas* canvas) {
     canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr);
 }
 bool SkDrawSpriteCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                      const SkPaint& paint) {
     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: "));
     fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: "));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawTextCommand::execute(SkCanvas* canvas) {
     canvas->drawText(fText, fByteLength, fX, fY, fPaint);
 }
 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength,
                                                  const SkPath& path, const SkMatrix* matrix,
                                                  const SkPaint& paint) {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fPath = path;
     if (NULL != matrix) {
         fMatrix = *matrix;
     } else {
         fMatrix.setIdentity();
     }
     fPaint = paint;
     fDrawType = DRAW_TEXT_ON_PATH;
     fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
     fInfo.push(SkObjectParser::PathToString(path));
     if (NULL != matrix) {
         fInfo.push(SkObjectParser::MatrixToString(*matrix));
     }
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) {
     canvas->drawTextOnPath(fText, fByteLength, fPath,
                            fMatrix.isIdentity() ? NULL : &fMatrix,
                            fPaint);
 }
 SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
                                              const SkPoint vertices[], const SkPoint texs[],
                                              const SkColor colors[], SkXfermode* xfermode,
                                              const uint16_t indices[], int indexCount,
                                              const SkPaint& paint) {
     fVmode = vmode;
     fVertexCount = vertexCount;
     fVertices = new SkPoint[vertexCount];
     memcpy(fVertices, vertices, vertexCount * sizeof(SkPoint));
     if (NULL != texs) {
         fTexs = new SkPoint[vertexCount];
         memcpy(fTexs, texs, vertexCount * sizeof(SkPoint));
     } else {
         fTexs = NULL;
     }
     if (NULL != colors) {
         fColors = new SkColor[vertexCount];
         memcpy(fColors, colors, vertexCount * sizeof(SkColor));
     } else {
         fColors = NULL;
     }
     fXfermode = xfermode;
     if (NULL != fXfermode) {
         fXfermode->ref();
     }
     if (indexCount > 0) {
         fIndices = new uint16_t[indexCount];
         memcpy(fIndices, indices, indexCount * sizeof(uint16_t));
     } else {
         fIndices = NULL;
     }
     fIndexCount = indexCount;
     fPaint = paint;
     fDrawType = DRAW_VERTICES;
     // TODO(chudy)
     fInfo.push(SkObjectParser::CustomTextToString("To be implemented."));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 SkDrawVerticesCommand::~SkDrawVerticesCommand() {
     delete [] fVertices;
     delete [] fTexs;
     delete [] fColors;
     SkSafeUnref(fXfermode);
     delete [] fIndices;
 }
 void SkDrawVerticesCommand::execute(SkCanvas* canvas) {
     canvas->drawVertices(fVmode, fVertexCount, fVertices,
                          fTexs, fColors, fXfermode, fIndices,
                          fIndexCount, fPaint);
 }
 SkRestoreCommand::SkRestoreCommand() {
     fDrawType = RESTORE;
     fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 void SkRestoreCommand::execute(SkCanvas* canvas) {
     canvas->restore();
 }
 void SkRestoreCommand::trackSaveState(int* state) {
     (*state)--;
 }
 SkRotateCommand::SkRotateCommand(SkScalar degrees) {
     fDegrees = degrees;
     fDrawType = ROTATE;
     fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: "));
 }
 void SkRotateCommand::execute(SkCanvas* canvas) {
     canvas->rotate(fDegrees);
 }
 SkSaveCommand::SkSaveCommand(SkCanvas::SaveFlags flags) {
     fFlags = flags;
     fDrawType = SAVE;
     fInfo.push(SkObjectParser::SaveFlagsToString(flags));
 }
 void SkSaveCommand::execute(SkCanvas* canvas) {
     canvas->save(fFlags);
 }
 void SkSaveCommand::trackSaveState(int* state) {
     (*state)++;
 }
 SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
                                        SkCanvas::SaveFlags flags) {
     if (NULL != bounds) {
         fBounds = *bounds;
     } else {
         fBounds.setEmpty();
     }
     if (NULL != paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fFlags = flags;
     fDrawType = SAVE_LAYER;
     if (NULL != bounds) {
         fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: "));
     }
     if (NULL != paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
     fInfo.push(SkObjectParser::SaveFlagsToString(flags));
 }
 void SkSaveLayerCommand::execute(SkCanvas* canvas) {
     canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds,
                       fPaintPtr,
                       fFlags);
 }
 void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) {
     canvas->save();
 }
 void SkSaveLayerCommand::trackSaveState(int* state) {
     (*state)++;
 }
 SkScaleCommand::SkScaleCommand(SkScalar sx, SkScalar sy) {
     fSx = sx;
     fSy = sy;
     fDrawType = SCALE;
     fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: "));
     fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: "));
 }
 void SkScaleCommand::execute(SkCanvas* canvas) {
     canvas->scale(fSx, fSy);
 }
 SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) {
     fMatrix = matrix;
     fDrawType = SET_MATRIX;
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 void SkSetMatrixCommand::execute(SkCanvas* canvas) {
     canvas->setMatrix(fMatrix);
 }
 SkSkewCommand::SkSkewCommand(SkScalar sx, SkScalar sy) {
     fSx = sx;
     fSy = sy;
     fDrawType = SKEW;
     fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: "));
     fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: "));
 }
 void SkSkewCommand::execute(SkCanvas* canvas) {
     canvas->skew(fSx, fSy);
 }
 SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) {
     fDx = dx;
     fDy = dy;
     fDrawType = TRANSLATE;
     fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: "));
     fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: "));
 }
 void SkTranslateCommand::execute(SkCanvas* canvas) {
     canvas->translate(fDx, fDy);
 }
 SkPushCullCommand::SkPushCullCommand(const SkRect& cullRect)
     : fCullRect(cullRect) {
     fDrawType = PUSH_CULL;
     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() {
     fDrawType = POP_CULL;
 }
 void SkPopCullCommand::execute(SkCanvas* canvas) {
     canvas->popCull();
 }

The Tor Browser / annotate

gfx/skia/trunk/src/utils/debugger/SkDrawCommand.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/utils/debugger/SkDrawCommand.cpp