Modify gpu debug markers to store gpu device markers when a flush occurs.

BUG=skia:
R=bsalomon@google.com

Author: egdaniel@google.com

Review URL: https://codereview.chromium.org/341583002

src/gpu/GrDrawTarget.cpp

@@ -578,7 +578,30 @@ void GrDrawTarget::drawPaths(int pathCount, const GrPath** paths,
                       dstCopy.texture() ? &dstCopy : NULL);
 }
 
-void GrDrawTarget::addGpuTraceMarker(GrGpuTraceMarker* marker) {
+typedef GrTraceMarkerSet::Iter TMIter;
+void GrDrawTarget::saveActiveTraceMarkers() {
+    if (this->caps()->gpuTracingSupport()) {
+        SkASSERT(0 == fStoredTraceMarkers.count());
+        fStoredTraceMarkers.addSet(fActiveTraceMarkers);
+        for (TMIter iter = fStoredTraceMarkers.begin(); iter != fStoredTraceMarkers.end(); ++iter) {
+            this->removeGpuTraceMarker(&(*iter));
+        }
+    }
+}
+
+void GrDrawTarget::restoreActiveTraceMarkers() {
+    if (this->caps()->gpuTracingSupport()) {
+        SkASSERT(0 == fActiveTraceMarkers.count());
+        for (TMIter iter = fStoredTraceMarkers.begin(); iter != fStoredTraceMarkers.end(); ++iter) {
+            this->addGpuTraceMarker(&(*iter));
+        }
+        for (TMIter iter = fActiveTraceMarkers.begin(); iter != fActiveTraceMarkers.end(); ++iter) {
+            this->fStoredTraceMarkers.remove(*iter);
+        }
+    }
+}
+
+void GrDrawTarget::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(fGpuTraceMarkerCount >= 0);
         this->fActiveTraceMarkers.add(*marker);
@@ -587,7 +610,7 @@ void GrDrawTarget::addGpuTraceMarker(GrGpuTraceMarker* marker) {
     }
 }
 
-void GrDrawTarget::removeGpuTraceMarker(GrGpuTraceMarker* marker) {
+void GrDrawTarget::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(fGpuTraceMarkerCount >= 1);
         this->fActiveTraceMarkers.remove(*marker);

src/gpu/GrDrawTarget.h

@@ -448,8 +448,19 @@ public:
      * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
      * and end of a code block respectively
      */
-    void addGpuTraceMarker(GrGpuTraceMarker* marker);
-    void removeGpuTraceMarker(GrGpuTraceMarker* marker);
+    void addGpuTraceMarker(const GrGpuTraceMarker* marker);
+    void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
+
+    /**
+     * Takes the current active set of markers and stores them for later use. Any current marker
+     * in the active set is removed from the active set and the targets remove function is called.
+     * These functions do not work as a stack so you cannot call save a second time before calling
+     * restore. Also, it is assumed that when restore is called the current active set of markers
+     * is empty. When the stored markers are added back into the active set, the targets add marker
+     * is called.
+     */
+    void saveActiveTraceMarkers();
+    void restoreActiveTraceMarkers();
 
     /**
      * Copies a pixel rectangle from one surface to another. This call may finalize
@@ -942,6 +953,7 @@ private:
     // To keep track that we always have at least as many debug marker adds as removes
     int                                                             fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                fActiveTraceMarkers;
+    GrTraceMarkerSet                                                fStoredTraceMarkers;
 
     typedef SkRefCnt INHERITED;
 };

src/gpu/GrInOrderDrawBuffer.cpp

@@ -591,6 +591,7 @@ void GrInOrderDrawBuffer::flush() {
     int currCopySurface = 0;
     int currCmdMarker   = 0;
 
+    fDstGpu->saveActiveTraceMarkers();
     for (int c = 0; c < numCmds; ++c) {
         GrGpuTraceMarker newMarker("", -1);
         if (cmd_has_trace_marker(fCmds[c])) {
@@ -666,6 +667,7 @@ void GrInOrderDrawBuffer::flush() {
             fDstGpu->removeGpuTraceMarker(&newMarker);
         }
     }
+    fDstGpu->restoreActiveTraceMarkers();
     // we should have consumed all the states, clips, etc.
     SkASSERT(fStates.count() == currState);
     SkASSERT(fClips.count() == currClip);

src/gpu/GrTraceMarker.cpp

@@ -13,36 +13,6 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class GrTraceMarkerSet::Iter {
-public:
-    Iter() {};
-    Iter& operator=(const Iter& i) {
-        fCurrentIndex = i.fCurrentIndex;
-        fMarkers = i.fMarkers;
-        return *this;
-    }
-    bool operator==(const Iter& i) const {
-        return fCurrentIndex == i.fCurrentIndex && fMarkers == i.fMarkers;
-    }
-    bool operator!=(const Iter& i) const { return !(*this == i); }
-    const GrGpuTraceMarker& operator*() const { return fMarkers->fMarkerArray[fCurrentIndex]; }
-    Iter& operator++() {
-        SkASSERT(*this != fMarkers->end());
-        ++fCurrentIndex;
-        return *this;
-    }
-
-private:
-    friend class GrTraceMarkerSet;
-    Iter(const GrTraceMarkerSet* markers, int index)
-            : fMarkers(markers), fCurrentIndex(index) {
-        SkASSERT(markers);
-    }
-
-    const GrTraceMarkerSet* fMarkers;
-    int fCurrentIndex;
-};
-
 ////////////////////////////////////////////////////////////////////////////////
 
 GrTraceMarkerSet::GrTraceMarkerSet(const GrTraceMarkerSet& other) {
@@ -114,3 +84,4 @@ GrTraceMarkerSet::Iter GrTraceMarkerSet::begin() const {
 GrTraceMarkerSet::Iter GrTraceMarkerSet::end() const {
     return Iter(this, this->fMarkerArray.count());
 }
+

src/gpu/GrTraceMarker.h

@@ -65,4 +65,34 @@ private:
     mutable SkTDArray<GrGpuTraceMarker> fMarkerArray;
 };
 
+class GrTraceMarkerSet::Iter {
+public:
+    Iter() {};
+    Iter& operator=(const Iter& i) {
+        fCurrentIndex = i.fCurrentIndex;
+        fMarkers = i.fMarkers;
+        return *this;
+    }
+    bool operator==(const Iter& i) const {
+        return fCurrentIndex == i.fCurrentIndex && fMarkers == i.fMarkers;
+    }
+    bool operator!=(const Iter& i) const { return !(*this == i); }
+    const GrGpuTraceMarker& operator*() const { return fMarkers->fMarkerArray[fCurrentIndex]; }
+    Iter& operator++() {
+        SkASSERT(*this != fMarkers->end());
+        ++fCurrentIndex;
+        return *this;
+    }
+
+private:
+    friend class GrTraceMarkerSet;
+    Iter(const GrTraceMarkerSet* markers, int index)
+            : fMarkers(markers), fCurrentIndex(index) {
+        SkASSERT(markers);
+    }
+
+    const GrTraceMarkerSet* fMarkers;
+    int fCurrentIndex;
+};
+
 #endif