The Tor Browser: gfx/skia/trunk/src/utils/debugger/SkDrawCommand.h@129ffea94266

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.

     2 /*

     3  * Copyright 2012 Google Inc.

     4  *

     5  * Use of this source code is governed by a BSD-style license that can be

     6  * found in the LICENSE file.

     7  */

     9 #ifndef SKDRAWCOMMAND_H_

    10 #define SKDRAWCOMMAND_H_

    12 #include "SkPictureFlat.h"

    13 #include "SkCanvas.h"

    14 #include "SkString.h"

    16 class SK_API SkDrawCommand {

    17 public:

    18     /* TODO(chudy): Remove subclasses. */

    19     SkDrawCommand(DrawType drawType);

    20     SkDrawCommand();

    22     virtual ~SkDrawCommand();

    24     virtual SkString toString();

    26     virtual const char* toCString() {

    27         return GetCommandString(fDrawType);

    28     }

    30     bool isVisible() const {

    31         return fVisible;

    32     }

    34     void setVisible(bool toggle) {

    35         fVisible = toggle;

    36     }

    38     SkTDArray<SkString*>* Info() {return &fInfo; };

    39     virtual void execute(SkCanvas* canvas) = 0;

    40     virtual void vizExecute(SkCanvas* canvas) { };

    41     /** Does nothing by default, but used by save() and restore()-type

    42         subclasses to track unresolved save() calls. */

    43     virtual void trackSaveState(int* state) { };

    45     // The next "active" system is only used by save, saveLayer, restore,

    46     // pushCull and popCull. It is used in two ways:

    47     // To determine which saveLayers are currently active (at a

    48     // given point in the rendering).

    49     //      save just return a kPushLayer action but don't track active state

    50     //      restore just return a kPopLayer action

    51     //      saveLayers return kPushLayer but also track the active state

    52     // To determine which culls are currently active (at a given point)

    53     // in the rendering).

    54     //      pushCull returns a kPushCull action

    55     //      popCull  returns a kPopCull action

    56     enum Action {

    57         kNone_Action,

    58         kPopLayer_Action,

    59         kPushLayer_Action,

    60         kPopCull_Action,

    61         kPushCull_Action

    62     };

    63     virtual Action action() const { return kNone_Action; }

    64     virtual void setActive(bool active) {}

    65     virtual bool active() const { return false; }

    67     DrawType getType() { return fDrawType; };

    69     virtual bool render(SkCanvas* canvas) const { return false; }

    71     static const char* GetCommandString(DrawType type);

    73 protected:

    74     DrawType fDrawType;

    75     SkTDArray<SkString*> fInfo;

    77 private:

    78     bool fVisible;

    79 };

    81 class SkRestoreCommand : public SkDrawCommand {

    82 public:

    83     SkRestoreCommand();

    84     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

    85     virtual void trackSaveState(int* state) SK_OVERRIDE;

    86     virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; }

    88 private:

    89     typedef SkDrawCommand INHERITED;

    90 };

    92 class SkClearCommand : public SkDrawCommand {

    93 public:

    94     SkClearCommand(SkColor color);

    95     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

    96 private:

    97     SkColor fColor;

    99     typedef SkDrawCommand INHERITED;

   100 };

   102 class SkClipPathCommand : public SkDrawCommand {

   103 public:

   104     SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA);

   105     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   106     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   107 private:

   108     SkPath       fPath;

   109     SkRegion::Op fOp;

   110     bool         fDoAA;

   112     typedef SkDrawCommand INHERITED;

   113 };

   115 class SkClipRegionCommand : public SkDrawCommand {

   116 public:

   117     SkClipRegionCommand(const SkRegion& region, SkRegion::Op op);

   118     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   119 private:

   120     SkRegion     fRegion;

   121     SkRegion::Op fOp;

   123     typedef SkDrawCommand INHERITED;

   124 };

   126 class SkClipRectCommand : public SkDrawCommand {

   127 public:

   128     SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA);

   129     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   131     const SkRect& rect() const { return fRect; }

   132     SkRegion::Op op() const { return fOp; }

   133     bool doAA() const { return fDoAA; }

   135 private:

   136     SkRect       fRect;

   137     SkRegion::Op fOp;

   138     bool         fDoAA;

   140     typedef SkDrawCommand INHERITED;

   141 };

   143 class SkClipRRectCommand : public SkDrawCommand {

   144 public:

   145     SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA);

   146     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   147     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   149     const SkRRect& rrect() const { return fRRect; }

   150     SkRegion::Op op() const { return fOp; }

   151     bool doAA() const { return fDoAA; }

   153 private:

   154     SkRRect      fRRect;

   155     SkRegion::Op fOp;

   156     bool         fDoAA;

   158     typedef SkDrawCommand INHERITED;

   159 };

   161 class SkConcatCommand : public SkDrawCommand {

   162 public:

   163     SkConcatCommand(const SkMatrix& matrix);

   164     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   165 private:

   166     SkMatrix fMatrix;

   168     typedef SkDrawCommand INHERITED;

   169 };

   171 class SkDrawBitmapCommand : public SkDrawCommand {

   172 public:

   173     SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,

   174                const SkPaint* paint);

   175     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   176     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   177 private:

   178     SkBitmap fBitmap;

   179     SkScalar fLeft;

   180     SkScalar fTop;

   181     SkPaint  fPaint;

   182     SkPaint* fPaintPtr;

   184     typedef SkDrawCommand INHERITED;

   185 };

   187 class SkDrawBitmapMatrixCommand : public SkDrawCommand {

   188 public:

   189     SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix,

   190                      const SkPaint* paint);

   191     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   192     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   193 private:

   194     SkBitmap fBitmap;

   195     SkMatrix fMatrix;

   196     SkPaint  fPaint;

   197     SkPaint* fPaintPtr;

   199     typedef SkDrawCommand INHERITED;

   200 };

   202 class SkDrawBitmapNineCommand : public SkDrawCommand {

   203 public:

   204     SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,

   205                    const SkRect& dst, const SkPaint* paint);

   206     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   207     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   208 private:

   209     SkBitmap fBitmap;

   210     SkIRect  fCenter;

   211     SkRect   fDst;

   212     SkPaint  fPaint;

   213     SkPaint* fPaintPtr;

   215     typedef SkDrawCommand INHERITED;

   216 };

   218 class SkDrawBitmapRectCommand : public SkDrawCommand {

   219 public:

   220     SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,

   221                             const SkRect& dst, const SkPaint* paint,

   222                             SkCanvas::DrawBitmapRectFlags flags);

   223     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   224     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   226     const SkBitmap& bitmap() const { return fBitmap; }

   228     // The non-const 'paint' method allows modification of this object's

   229     // SkPaint. For this reason the ctor and setPaint method make a local copy.

   230     // The 'fPaintPtr' member acts a signal that the local SkPaint is valid

   231     // (since only an SkPaint* is passed into the ctor).

   232     const SkPaint* paint() const { return fPaintPtr; }

   233     SkPaint* paint() { return fPaintPtr; }

   235     void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; }

   237     const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; }

   238     void setSrcRect(const SkRect& src) { fSrc = src; }

   240     const SkRect& dstRect() const { return fDst; }

   241     void setDstRect(const SkRect& dst) { fDst = dst; }

   243     SkCanvas::DrawBitmapRectFlags flags() const { return fFlags; }

   244     void setFlags(SkCanvas::DrawBitmapRectFlags flags) { fFlags = flags; }

   246 private:

   247     SkBitmap                      fBitmap;

   248     SkRect                        fSrc;

   249     SkRect                        fDst;

   250     SkPaint                       fPaint;

   251     SkPaint*                      fPaintPtr;

   252     SkCanvas::DrawBitmapRectFlags fFlags;

   254     typedef SkDrawCommand INHERITED;

   255 };

   257 class SkDrawDataCommand : public SkDrawCommand {

   258 public:

   259     SkDrawDataCommand(const void* data, size_t length);

   260     virtual ~SkDrawDataCommand() { delete [] fData; }

   261     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   262 private:

   263     char*  fData;

   264     size_t fLength;

   266     typedef SkDrawCommand INHERITED;

   267 };

   269 class SkBeginCommentGroupCommand : public SkDrawCommand {

   270 public:

   271     SkBeginCommentGroupCommand(const char* description);

   272     virtual void execute(SkCanvas* canvas) SK_OVERRIDE {

   273         canvas->beginCommentGroup(fDescription.c_str());

   274     };

   275 private:

   276     SkString fDescription;

   278     typedef SkDrawCommand INHERITED;

   279 };

   281 class SkCommentCommand : public SkDrawCommand {

   282 public:

   283     SkCommentCommand(const char* kywd, const char* value);

   284     virtual void execute(SkCanvas* canvas) SK_OVERRIDE {

   285         canvas->addComment(fKywd.c_str(), fValue.c_str());

   286     };

   287 private:

   288     SkString fKywd;

   289     SkString fValue;

   291     typedef SkDrawCommand INHERITED;

   292 };

   294 class SkEndCommentGroupCommand : public SkDrawCommand {

   295 public:

   296     SkEndCommentGroupCommand();

   297     virtual void execute(SkCanvas* canvas) SK_OVERRIDE {

   298         canvas->endCommentGroup();

   299     };

   300 private:

   301     typedef SkDrawCommand INHERITED;

   302 };

   304 class SkDrawOvalCommand : public SkDrawCommand {

   305 public:

   306     SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint);

   307     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   308     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   309 private:

   310     SkRect  fOval;

   311     SkPaint fPaint;

   313     typedef SkDrawCommand INHERITED;

   314 };

   316 class SkDrawPaintCommand : public SkDrawCommand {

   317 public:

   318     SkDrawPaintCommand(const SkPaint& paint);

   319     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   320     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   321 private:

   322     SkPaint fPaint;

   324     typedef SkDrawCommand INHERITED;

   325 };

   327 class SkDrawPathCommand : public SkDrawCommand {

   328 public:

   329     SkDrawPathCommand(const SkPath& path, const SkPaint& paint);

   330     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   331     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   333 private:

   334     SkPath   fPath;

   335     SkPaint  fPaint;

   337     typedef SkDrawCommand INHERITED;

   338 };

   340 class SkDrawPictureCommand : public SkDrawCommand {

   341 public:

   342     SkDrawPictureCommand(SkPicture& picture);

   343     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   344     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   346 private:

   347     SkPicture fPicture;

   349     typedef SkDrawCommand INHERITED;

   350 };

   352 class SkDrawPointsCommand : public SkDrawCommand {

   353 public:

   354     SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],

   355                const SkPaint& paint);

   356     virtual ~SkDrawPointsCommand() { delete [] fPts; }

   357     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   358     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   359 private:

   360     SkCanvas::PointMode fMode;

   361     size_t              fCount;

   362     SkPoint*            fPts;

   363     SkPaint             fPaint;

   365     typedef SkDrawCommand INHERITED;

   366 };

   368 class SkDrawTextCommand : public SkDrawCommand {

   369 public:

   370     SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,

   371               const SkPaint& paint);

   372     virtual ~SkDrawTextCommand() { delete [] fText; }

   373     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   374 private:

   375     char*    fText;

   376     size_t   fByteLength;

   377     SkScalar fX;

   378     SkScalar fY;

   379     SkPaint  fPaint;

   381     typedef SkDrawCommand INHERITED;

   382 };

   384 class SkDrawPosTextCommand : public SkDrawCommand {

   385 public:

   386     SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[],

   387                          const SkPaint& paint);

   388     virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; }

   389     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   390 private:

   391     char*    fText;

   392     size_t   fByteLength;

   393     SkPoint* fPos;

   394     SkPaint  fPaint;

   396     typedef SkDrawCommand INHERITED;

   397 };

   399 class SkDrawTextOnPathCommand : public SkDrawCommand {

   400 public:

   401     SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path,

   402                             const SkMatrix* matrix, const SkPaint& paint);

   403     virtual ~SkDrawTextOnPathCommand() { delete [] fText; }

   404     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   405 private:

   406     char*    fText;

   407     size_t   fByteLength;

   408     SkPath   fPath;

   409     SkMatrix fMatrix;

   410     SkPaint  fPaint;

   412     typedef SkDrawCommand INHERITED;

   413 };

   415 class SkDrawPosTextHCommand : public SkDrawCommand {

   416 public:

   417     SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[],

   418                           SkScalar constY, const SkPaint& paint);

   419     virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; }

   420     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   421 private:

   422     SkScalar* fXpos;

   423     char*     fText;

   424     size_t    fByteLength;

   425     SkScalar  fConstY;

   426     SkPaint   fPaint;

   428     typedef SkDrawCommand INHERITED;

   429 };

   431 class SkDrawRectCommand : public SkDrawCommand {

   432 public:

   433     SkDrawRectCommand(const SkRect& rect, const SkPaint& paint);

   434     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   436     const SkRect& rect() const   { return fRect; }

   437     const SkPaint& paint() const { return fPaint; }

   438 private:

   439     SkRect  fRect;

   440     SkPaint fPaint;

   442     typedef SkDrawCommand INHERITED;

   443 };

   445 class SkDrawRRectCommand : public SkDrawCommand {

   446 public:

   447     SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint);

   448     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   449     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   450 private:

   451     SkRRect fRRect;

   452     SkPaint fPaint;

   454     typedef SkDrawCommand INHERITED;

   455 };

   457 class SkDrawDRRectCommand : public SkDrawCommand {

   458 public:

   459     SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner,

   460                         const SkPaint& paint);

   461     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   462     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   463 private:

   464     SkRRect fOuter;

   465     SkRRect fInner;

   466     SkPaint fPaint;

   468     typedef SkDrawCommand INHERITED;

   469 };

   471 class SkDrawSpriteCommand : public SkDrawCommand {

   472 public:

   473     SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);

   474     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   475     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;

   476 private:

   477     SkBitmap fBitmap;

   478     int      fLeft;

   479     int      fTop;

   480     SkPaint  fPaint;

   481     SkPaint* fPaintPtr;

   483     typedef SkDrawCommand INHERITED;

   484 };

   486 class SkDrawVerticesCommand : public SkDrawCommand {

   487 public:

   488     SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,

   489                           const SkPoint vertices[], const SkPoint texs[],

   490                           const SkColor colors[], SkXfermode* xfermode,

   491                           const uint16_t indices[], int indexCount,

   492                           const SkPaint& paint);

   493     virtual ~SkDrawVerticesCommand();

   494     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   495 private:

   496     SkCanvas::VertexMode fVmode;

   497     int         fVertexCount;

   498     SkPoint*    fVertices;

   499     SkPoint*    fTexs;

   500     SkColor*    fColors;

   501     SkXfermode* fXfermode;

   502     uint16_t*   fIndices;

   503     int         fIndexCount;

   504     SkPaint     fPaint;

   506     typedef SkDrawCommand INHERITED;

   507 };

   509 class SkRotateCommand : public SkDrawCommand {

   510 public:

   511     SkRotateCommand(SkScalar degrees);

   512     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   513 private:

   514     SkScalar fDegrees;

   516     typedef SkDrawCommand INHERITED;

   517 };

   519 class SkSaveCommand : public SkDrawCommand {

   520 public:

   521     SkSaveCommand(SkCanvas::SaveFlags flags);

   522     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   523     virtual void trackSaveState(int* state) SK_OVERRIDE;

   524     virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; }

   525 private:

   526     SkCanvas::SaveFlags fFlags;

   528     typedef SkDrawCommand INHERITED;

   529 };

   531 class SkSaveLayerCommand : public SkDrawCommand {

   532 public:

   533     SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,

   534                        SkCanvas::SaveFlags flags);

   535     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   536     virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;

   537     virtual void trackSaveState(int* state) SK_OVERRIDE;

   538     virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; }

   539     virtual void setActive(bool active) SK_OVERRIDE { fActive = active; }

   540     virtual bool active() const SK_OVERRIDE { return fActive; }

   542     const SkPaint* paint() const { return fPaintPtr; }

   544 private:

   545     SkRect              fBounds;

   546     SkPaint             fPaint;

   547     SkPaint*            fPaintPtr;

   548     SkCanvas::SaveFlags fFlags;

   550     bool                fActive;

   552     typedef SkDrawCommand INHERITED;

   553 };

   555 class SkScaleCommand : public SkDrawCommand {

   556 public:

   557     SkScaleCommand(SkScalar sx, SkScalar sy);

   558     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   560     SkScalar x() const { return fSx; }

   561     SkScalar y() const { return fSy; }

   563 private:

   564     SkScalar fSx;

   565     SkScalar fSy;

   567     typedef SkDrawCommand INHERITED;

   568 };

   570 class SkSetMatrixCommand : public SkDrawCommand {

   571 public:

   572     SkSetMatrixCommand(const SkMatrix& matrix);

   573     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   574 private:

   575     SkMatrix fMatrix;

   577     typedef SkDrawCommand INHERITED;

   578 };

   580 class SkSkewCommand : public SkDrawCommand {

   581 public:

   582     SkSkewCommand(SkScalar sx, SkScalar sy);

   583     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   584 private:

   585     SkScalar fSx;

   586     SkScalar fSy;

   588     typedef SkDrawCommand INHERITED;

   589 };

   591 class SkTranslateCommand : public SkDrawCommand {

   592 public:

   593     SkTranslateCommand(SkScalar dx, SkScalar dy);

   594     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   596     SkScalar x() const { return fDx; }

   597     SkScalar y() const { return fDy; }

   599 private:

   600     SkScalar fDx;

   601     SkScalar fDy;

   603     typedef SkDrawCommand INHERITED;

   604 };

   606 class SkPushCullCommand : public SkDrawCommand {

   607 public:

   608     SkPushCullCommand(const SkRect&);

   609     virtual void execute(SkCanvas*) SK_OVERRIDE;

   610     virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;

   611     virtual Action action() const { return kPushCull_Action; }

   612     virtual void setActive(bool active) { fActive = active; }

   613     virtual bool active() const { return fActive; }

   614 private:

   615     SkRect fCullRect;

   616     bool   fActive;

   618     typedef SkDrawCommand INHERITED;

   619 };

   621 class SkPopCullCommand : public SkDrawCommand {

   622 public:

   623     SkPopCullCommand();

   624     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;

   625     virtual Action action() const { return kPopCull_Action; }

   626 private:

   627     typedef SkDrawCommand INHERITED;

   628 };

   630 #endif

The Tor Browser / file revision

gfx/skia/trunk/src/utils/debugger/SkDrawCommand.h@129ffea94266

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