Remove code that was only used by the old debugger

Change-Id: I1035d9fa5f9888f3b6c332b16a0bde69f357a4a8
Reviewed-on: https://skia-review.googlesource.com/119144
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>

1 files changed, 5 insertions, 270 deletions

diff --git a/tools/debugger/SkDebugCanvas.cpp b/tools/debugger/SkDebugCanvas.cpp
index 8644025c48..156f957de3 100644
--- a/tools/debugger/SkDebugCanvas.cpp
+++ b/tools/debugger/SkDebugCanvas.cpp
@@ -6,10 +6,10 @@
  */
 
 #include "SkCanvasPriv.h"
-#include "SkClipStack.h"
 #include "SkDebugCanvas.h"
 #include "SkDrawCommand.h"
 #include "SkPaintFilterCanvas.h"
+#include "SkPicture.h"
 #include "SkRectPriv.h"
 #include "SkTextBlob.h"
 #include "SkClipOpPriv.h"
@@ -28,13 +28,9 @@
 class DebugPaintFilterCanvas : public SkPaintFilterCanvas {
 public:
     DebugPaintFilterCanvas(SkCanvas* canvas,
-                           bool overdrawViz,
-                           bool overrideFilterQuality,
-                           SkFilterQuality quality)
+                           bool overdrawViz)
         : INHERITED(canvas)
-        , fOverdrawViz(overdrawViz)
-        , fOverrideFilterQuality(overrideFilterQuality)
-        , fFilterQuality(quality) {}
+        , fOverdrawViz(overdrawViz) {}
 
 protected:
     bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type) const override {
@@ -44,10 +40,6 @@ protected:
                 paint->writable()->setAlpha(0x08);
                 paint->writable()->setBlendMode(SkBlendMode::kSrcOver);
             }
-
-            if (fOverrideFilterQuality) {
-                paint->writable()->setFilterQuality(fFilterQuality);
-            }
         }
         return true;
     }
@@ -61,24 +53,15 @@ protected:
 
 private:
     bool fOverdrawViz;
-    bool fOverrideFilterQuality;
-    SkFilterQuality fFilterQuality;
 
     typedef SkPaintFilterCanvas INHERITED;
 };
 
 SkDebugCanvas::SkDebugCanvas(int width, int height)
         : INHERITED(width, height)
-        , fPicture(nullptr)
-        , fFilter(false)
-        , fMegaVizMode(false)
         , fOverdrawViz(false)
-        , fOverrideFilterQuality(false)
-        , fFilterQuality(kNone_SkFilterQuality)
         , fClipVizColor(SK_ColorTRANSPARENT)
         , fDrawGpuOpBounds(false) {
-    fUserMatrix.reset();
-
     // SkPicturePlayback uses the base-class' quickReject calls to cull clipped
     // operations. This can lead to problems in the debugger which expects all
     // the operations in the captured skp to appear in the debug canvas. To
@@ -112,57 +95,6 @@ void SkDebugCanvas::draw(SkCanvas* canvas) {
     }
 }
 
-void SkDebugCanvas::applyUserTransform(SkCanvas* canvas) {
-    canvas->concat(fUserMatrix);
-}
-
-int SkDebugCanvas::getCommandAtPoint(int x, int y, int index) {
-    SkBitmap bitmap;
-    bitmap.allocPixels(SkImageInfo::MakeN32Premul(1, 1));
-
-    SkCanvas canvas(bitmap);
-    canvas.translate(SkIntToScalar(-x), SkIntToScalar(-y));
-    this->applyUserTransform(&canvas);
-
-    int layer = 0;
-    SkColor prev = bitmap.getColor(0,0);
-    for (int i = 0; i < index; i++) {
-        if (fCommandVector[i]->isVisible()) {
-            fCommandVector[i]->setUserMatrix(fUserMatrix);
-            fCommandVector[i]->execute(&canvas);
-        }
-        if (prev != bitmap.getColor(0,0)) {
-            layer = i;
-        }
-        prev = bitmap.getColor(0,0);
-    }
-    return layer;
-}
-
-// set up the saveLayer commands so that the active ones
-// return true in their 'active' method
-void SkDebugCanvas::markActiveCommands(int index) {
-    fActiveLayers.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();
-        }
-    }
-
-    for (int i = 0; i < fActiveLayers.count(); ++i) {
-        fActiveLayers[i]->setActive(true);
-    }
-
-}
-
 void SkDebugCanvas::drawTo(SkCanvas* originalCanvas, int index, int m) {
     SkASSERT(!fCommandVector.isEmpty());
     SkASSERT(index < fCommandVector.count());
@@ -172,21 +104,13 @@ void SkDebugCanvas::drawTo(SkCanvas* originalCanvas, int index, int m) {
     SkRect windowRect = SkRect::MakeWH(SkIntToScalar(originalCanvas->getBaseLayerSize().width()),
                                        SkIntToScalar(originalCanvas->getBaseLayerSize().height()));
 
-    bool pathOpsMode = getAllowSimplifyClip();
-    originalCanvas->setAllowSimplifyClip(pathOpsMode);
     originalCanvas->clear(SK_ColorWHITE);
     originalCanvas->resetMatrix();
     if (!windowRect.isEmpty()) {
         originalCanvas->clipRect(windowRect, kReplace_SkClipOp);
     }
-    this->applyUserTransform(originalCanvas);
 
-    DebugPaintFilterCanvas filterCanvas(originalCanvas, fOverdrawViz, fOverrideFilterQuality,
-                                        fFilterQuality);
-
-    if (fMegaVizMode) {
-        this->markActiveCommands(index);
-    }
+    DebugPaintFilterCanvas filterCanvas(originalCanvas, fOverdrawViz);
 
 #if SK_SUPPORT_GPU
     // If we have a GPU backend we can also visualize the op information
@@ -198,10 +122,6 @@ void SkDebugCanvas::drawTo(SkCanvas* originalCanvas, int index, int m) {
 #endif
 
     for (int i = 0; i <= index; i++) {
-        if (i == index && fFilter) {
-            filterCanvas.clear(0xAAFFFFFF);
-        }
-
 #if SK_SUPPORT_GPU
         // We need to flush any pending operations, or they might combine with commands below.
         // Previous operations were not registered with the audit trail when they were
@@ -215,16 +135,7 @@ void SkDebugCanvas::drawTo(SkCanvas* originalCanvas, int index, int m) {
 #endif
 
         if (fCommandVector[i]->isVisible()) {
-            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(&filterCanvas);
-            } else {
-                fCommandVector[i]->setUserMatrix(fUserMatrix);
-                fCommandVector[i]->execute(&filterCanvas);
-            }
+            fCommandVector[i]->execute(&filterCanvas);
         }
 #if SK_SUPPORT_GPU
         if (at && acb) {
@@ -245,28 +156,6 @@ void SkDebugCanvas::drawTo(SkCanvas* originalCanvas, int index, int m) {
         filterCanvas.restore();
     }
 
-    if (pathOpsMode) {
-        this->resetClipStackData();
-        const SkClipStack* clipStack = nullptr;//HACK filterCanvas.getClipStack();
-        SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
-        const SkClipStack::Element* element;
-        SkPath devPath;
-        while ((element = iter.next())) {
-            SkClipStack::Element::DeviceSpaceType type = element->getDeviceSpaceType();
-            SkPath operand;
-            if (type != SkClipStack::Element::DeviceSpaceType::kEmpty) {
-                element->asDeviceSpacePath(&operand);
-            }
-            SkClipOp elementOp = element->getOp();
-            this->addClipStackData(devPath, operand, elementOp);
-            if (elementOp == kReplace_SkClipOp) {
-                devPath = operand;
-            } else {
-                Op(devPath, operand, (SkPathOp) elementOp, &devPath);
-            }
-        }
-        this->lastClipStackData(devPath);
-    }
     fMatrix = filterCanvas.getTotalMatrix();
     fClip = filterCanvas.getDeviceClipBounds();
     filterCanvas.restoreToCount(saveCount);
@@ -334,30 +223,6 @@ SkDrawCommand* SkDebugCanvas::getDrawCommandAt(int index) {
     return fCommandVector[index];
 }
 
-void SkDebugCanvas::setDrawCommandAt(int index, SkDrawCommand* command) {
-    SkASSERT(index < fCommandVector.count());
-    delete fCommandVector[index];
-    fCommandVector[index] = command;
-}
-
-const SkTDArray<SkString*>* SkDebugCanvas::getCommandInfo(int index) const {
-    SkASSERT(index < fCommandVector.count());
-    return fCommandVector[index]->Info();
-}
-
-bool SkDebugCanvas::getDrawCommandVisibilityAt(int index) {
-    SkASSERT(index < fCommandVector.count());
-    return fCommandVector[index]->isVisible();
-}
-
-const SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() const {
-    return fCommandVector;
-}
-
-SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() {
-    return fCommandVector;
-}
-
 GrAuditTrail* SkDebugCanvas::getAuditTrail(SkCanvas* canvas) {
     GrAuditTrail* at = nullptr;
 #if SK_SUPPORT_GPU
@@ -448,11 +313,6 @@ void SkDebugCanvas::setOverdrawViz(bool overdrawViz) {
     fOverdrawViz = overdrawViz;
 }
 
-void SkDebugCanvas::overrideTexFiltering(bool overrideTexFiltering, SkFilterQuality quality) {
-    fOverrideFilterQuality = overrideTexFiltering;
-    fFilterQuality = quality;
-}
-
 void SkDebugCanvas::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle) {
     this->addDrawCommand(new SkClipPathCommand(path, op, kSoft_ClipEdgeStyle == edgeStyle));
 }
@@ -634,128 +494,3 @@ 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[] = "&nbsp;&nbsp;&nbsp;&nbsp;";
-
-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::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(", ");
-        }
-    }
-}
-
-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;
-        }
-    }
-}
-
-void SkDebugCanvas::addClipStackData(const SkPath& devPath, const SkPath& operand,
-                                     SkClipOp elementOp) {
-    if (elementOp == kReplace_SkClipOp) {
-        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[static_cast<int>(elementOp)]);
-        fClipStackData.appendf("}<br>");
-        fCalledAddStackData = true;
-    }
-}
-
-bool SkDebugCanvas::lastClipStackData(const SkPath& devPath) {
-    if (fCalledAddStackData) {
-        fClipStackData.appendf("<br>");
-        addPathData(devPath, "pathOut");
-        return true;
-    }
-    return false;
-}