Implement "dump displaylist" button for skia pipelines

Implement "dump displaylist" button in hierarchyviewer for skia
pipelines.

Test: ran hierarchyviewer for all pipelines.
bug: 34819877
Change-Id: Ifeb578260f636cb67268f9f9259e7318bf7de453

libs/hwui/DisplayList.cpp

@@ -22,6 +22,7 @@
 #include "DamageAccumulator.h"
 #include "Debug.h"
 #include "DisplayList.h"
+#include "OpDumper.h"
 #include "RecordedOp.h"
 #include "RenderNode.h"
 #include "VectorDrawable.h"
@@ -127,5 +128,17 @@ bool DisplayList::prepareListAndChildren(TreeObserver& observer, TreeInfo& info,
     return isDirty;
 }
 
+void DisplayList::output(std::ostream& output, uint32_t level) {
+    for (auto&& op : getOps()) {
+        OpDumper::dump(*op, output, level + 1);
+        if (op->opId == RecordedOpId::RenderNodeOp) {
+            auto rnOp = reinterpret_cast<const RenderNodeOp*>(op);
+            rnOp->renderNode->output(output, level + 1);
+        } else {
+            output << std::endl;
+        }
+    }
+}
+
 }; // namespace uirenderer
 }; // namespace android

libs/hwui/DisplayList.h

@@ -128,6 +128,8 @@ public:
     virtual bool prepareListAndChildren(TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer,
             std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn);
 
+    virtual void output(std::ostream& output, uint32_t level);
+
 protected:
     // allocator into which all ops and LsaVector arrays allocated
     LinearAllocator allocator;

libs/hwui/RenderNode.cpp

@@ -19,7 +19,6 @@
 #include "BakedOpRenderer.h"
 #include "DamageAccumulator.h"
 #include "Debug.h"
-#include "OpDumper.h"
 #include "RecordedOp.h"
 #include "TreeInfo.h"
 #include "utils/FatVector.h"
@@ -99,15 +98,7 @@ void RenderNode::output(std::ostream& output, uint32_t level) {
     properties().debugOutputProperties(output, level + 1);
 
     if (mDisplayList) {
-        for (auto&& op : mDisplayList->getOps()) {
-            OpDumper::dump(*op, output, level + 1);
-            if (op->opId == RecordedOpId::RenderNodeOp) {
-                auto rnOp = reinterpret_cast<const RenderNodeOp*>(op);
-                rnOp->renderNode->output(output, level + 1);
-            } else {
-                output << std::endl;
-            }
-        }
+        mDisplayList->output(output, level);
     }
     output << std::string(level * 2, ' ') << "/RenderNode(" << getName() << " " << this << ")";
     output << std::endl;

libs/hwui/RenderNode.h

@@ -248,6 +248,8 @@ public:
     // Called by CanvasContext when it drops a RenderNode from being a root node
     void clearRoot();
 
+    void output(std::ostream& output, uint32_t level);
+
 private:
     void computeOrderingImpl(RenderNodeOp* opState,
             std::vector<RenderNodeOp*>* compositedChildrenOfProjectionSurface,
@@ -266,7 +268,6 @@ private:
 
     void incParentRefCount() { mParentCount++; }
     void decParentRefCount(TreeObserver& observer, TreeInfo* info = nullptr);
-    void output(std::ostream& output, uint32_t level);
 
     String8 mName;
     sp<VirtualLightRefBase> mUserContext;

libs/hwui/pipeline/skia/DumpOpsCanvas.h

@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "SkiaDisplayList.h"
+
+namespace android {
+namespace uirenderer {
+namespace skiapipeline {
+
+/**
+ * DumpOpsCanvas prints drawing ops from a SkiaDisplayList into a std::ostream. Children render
+ * nodes are walked recursively and their drawing ops are printed as well.
+ */
+class DumpOpsCanvas : public SkCanvas {
+public:
+    DumpOpsCanvas(std::ostream& output, int level, SkiaDisplayList& displayList)
+            : mOutput(output)
+            , mLevel(level)
+            , mDisplayList(displayList)
+            , mIdent((level + 1) * 2, ' ') {
+    }
+
+protected:
+    void onClipRect(const SkRect& rect, SkClipOp, ClipEdgeStyle) override {
+        mOutput << mIdent << "clipRect" << std::endl;
+    }
+
+    void onClipRRect(const SkRRect& rrect, SkClipOp, ClipEdgeStyle) override {
+        mOutput << mIdent << "clipRRect" << std::endl;
+    }
+
+    void onClipPath(const SkPath& path, SkClipOp, ClipEdgeStyle) override {
+        mOutput << mIdent << "clipPath" << std::endl;
+    }
+
+    void onClipRegion(const SkRegion& deviceRgn, SkClipOp) override {
+        mOutput << mIdent << "clipRegion" << std::endl;
+    }
+
+    void onDrawPaint(const SkPaint&) override {
+        mOutput << mIdent << "drawPaint" << std::endl;
+    }
+
+    void onDrawPath(const SkPath&, const SkPaint&) override {
+        mOutput << mIdent << "drawPath" << std::endl;
+    }
+
+    void onDrawRect(const SkRect&, const SkPaint&) override {
+        mOutput << mIdent << "drawRect" << std::endl;
+    }
+
+    void onDrawRegion(const SkRegion&, const SkPaint&) override {
+        mOutput << mIdent << "drawRegion" << std::endl;
+    }
+
+    void onDrawOval(const SkRect&, const SkPaint&) override {
+        mOutput << mIdent << "drawOval" << std::endl;
+    }
+
+    void onDrawArc(const SkRect&, SkScalar, SkScalar, bool, const SkPaint&) override {
+        mOutput << mIdent << "drawArc" << std::endl;
+    }
+
+    void onDrawRRect(const SkRRect&, const SkPaint&) override {
+        mOutput << mIdent << "drawRRect" << std::endl;
+    }
+
+    void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override {
+        mOutput << mIdent << "drawDRRect" << std::endl;
+    }
+
+    void onDrawText(const void*, size_t, SkScalar, SkScalar, const SkPaint&) override {
+        mOutput << mIdent << "drawText" << std::endl;
+    }
+
+    void onDrawPosText(const void*, size_t, const SkPoint[], const SkPaint&) override {
+        mOutput << mIdent << "drawPosText" << std::endl;
+    }
+
+    void onDrawPosTextH(const void*, size_t, const SkScalar[], SkScalar,
+            const SkPaint&) override {
+        mOutput << mIdent << "drawPosTextH" << std::endl;
+    }
+
+    void onDrawTextOnPath(const void*, size_t, const SkPath&, const SkMatrix*,
+            const SkPaint&) override {
+        mOutput << mIdent << "drawTextOnPath" << std::endl;
+    }
+
+    void onDrawTextRSXform(const void*, size_t, const SkRSXform[], const SkRect*,
+            const SkPaint&) override {
+        mOutput << mIdent << "drawTextRSXform" << std::endl;
+    }
+
+    void onDrawTextBlob(const SkTextBlob*, SkScalar,SkScalar, const SkPaint&) override {
+        mOutput << mIdent << "drawTextBlob" << std::endl;
+    }
+
+    void onDrawImage(const SkImage*, SkScalar dx, SkScalar dy, const SkPaint*) override {
+        mOutput << mIdent << "drawImage" << std::endl;
+    }
+
+    void onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
+            const SkPaint*) override {
+        mOutput << mIdent << "drawImageNine" << std::endl;
+    }
+
+    void onDrawImageRect(const SkImage*, const SkRect*, const SkRect&, const SkPaint*,
+            SrcRectConstraint) override {
+        mOutput << mIdent << "drawImageRect" << std::endl;
+    }
+
+    void onDrawImageLattice(const SkImage*, const Lattice& lattice, const SkRect& dst,
+            const SkPaint*) override {
+        mOutput << mIdent << "drawImageLattice" << std::endl;
+    }
+
+    void onDrawPoints(SkCanvas::PointMode, size_t, const SkPoint[], const SkPaint&) override {
+        mOutput << mIdent << "drawPoints" << std::endl;
+    }
+
+    void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override {
+        mOutput << mIdent << "drawPicture" << std::endl;
+    }
+
+    void onDrawDrawable(SkDrawable* drawable, const SkMatrix*) override {
+        mOutput << mIdent;
+        auto renderNodeDrawable = getRenderNodeDrawable(drawable);
+        if (nullptr != renderNodeDrawable) {
+            mOutput << std::string(mLevel * 2, ' ') << "drawRenderNode";
+            renderNodeDrawable->getRenderNode()->output(mOutput, mLevel + 1);
+            return;
+        }
+        auto glFunctorDrawable = getGLFunctorDrawable(drawable);
+        if (nullptr != glFunctorDrawable) {
+            mOutput << std::string(mLevel * 2, ' ') << "drawGLFunctorDrawable" << std::endl;
+            return;
+        }
+
+        mOutput << std::string(mLevel * 2, ' ') << "drawDrawable" << std::endl;
+    }
+
+private:
+    RenderNodeDrawable* getRenderNodeDrawable(SkDrawable* drawable) {
+         for (auto& child : mDisplayList.mChildNodes) {
+            if (drawable == &child) {
+                return &child;
+            }
+         }
+         return nullptr;
+    }
+
+    GLFunctorDrawable* getGLFunctorDrawable(SkDrawable* drawable) {
+         for (auto& child : mDisplayList.mChildFunctors) {
+            if (drawable == &child) {
+                return &child;
+            }
+         }
+         return nullptr;
+    }
+
+    std::ostream& mOutput;
+    int mLevel;
+    SkiaDisplayList& mDisplayList;
+    std::string mIdent;
+};
+
+}; // namespace skiapipeline
+}; // namespace uirenderer
+}; // namespace android

libs/hwui/pipeline/skia/SkiaDisplayList.cpp

@@ -18,6 +18,7 @@
 
 #include "renderthread/CanvasContext.h"
 #include "VectorDrawable.h"
+#include "DumpOpsCanvas.h"
 
 #include <SkImagePriv.h>
 
@@ -116,6 +117,11 @@ void SkiaDisplayList::reset(SkRect bounds) {
     new (&allocator) LinearAllocator();
 }
 
+void SkiaDisplayList::output(std::ostream& output, uint32_t level) {
+    DumpOpsCanvas canvas(output, level, *this);
+    mDrawable->draw(&canvas, nullptr);
+}
+
 }; // namespace skiapipeline
 }; // namespace uirenderer
 }; // namespace android

libs/hwui/pipeline/skia/SkiaDisplayList.h

@@ -126,6 +126,8 @@ public:
      */
     inline bool containsProjectionReceiver() const { return mProjectionReceiver; }
 
+    void output(std::ostream& output, uint32_t level) override;
+
     /**
      * We use std::deque here because (1) we need to iterate through these
      * elements and (2) mDrawable holds pointers to the elements, so they cannot