Add abilitly to query audit trail for batches by draw op

include/private/GrAuditTrail.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAuditTrail_DEFINED
 #define GrAuditTrail_DEFINED
 
@@ skipping 10 matching lines @@
  * to json.
  *
  * Capturing this information is expensive and consumes a lot of memory, therefore it is important
  * to enable auditing only when required and disable it promptly. The AutoEnable class helps to 
  * ensure that the audit trail is disabled in a timely fashion. Once the information has been dealt
  * with, be sure to call reset(), or the log will simply keep growing.
  */
 class GrAuditTrail {
 public:
     GrAuditTrail() 
-    : fEnabled(false)
-    , fUniqueID(0) {}
-
-    class AutoFrame {
-    public:
-        AutoFrame(GrAuditTrail* auditTrail, const char* name)
-            : fAuditTrail(auditTrail) {
-            if (fAuditTrail->fEnabled) {
-                fAuditTrail->pushFrame(name);
-            }
-        }
-
-        ~AutoFrame() {
-            if (fAuditTrail->fEnabled) {
-                fAuditTrail->popFrame();
-            }
-        }
-
-    private:
-        GrAuditTrail* fAuditTrail;
-    };
+    : fClientID(kInvalidID)
+    , fEnabled(false) {}
 
     class AutoEnable {
     public:
         AutoEnable(GrAuditTrail* auditTrail)
             : fAuditTrail(auditTrail) {
             SkASSERT(!fAuditTrail->isEnabled());
             fAuditTrail->setEnabled(true);
         }
 
         ~AutoEnable() {
@@ skipping 14 matching lines @@
 
         ~AutoManageBatchList() {
             fAuditTrail->fullReset();
         }
 
     private:
         AutoEnable fAutoEnable;
         GrAuditTrail* fAuditTrail;
     };
 
-    void pushFrame(const char* name) {
-        SkASSERT(fEnabled);
-        Frame* frame = new Frame;
-        fEvents.emplace_back(frame);
-        if (fStack.empty()) {
-            fFrames.push_back(frame);
-        } else {
-            fStack.back()->fChildren.push_back(frame);
+    class AutoCollectBatches {
+    public:
+        AutoCollectBatches(GrAuditTrail* auditTrail, int clientID)
+            : fAutoEnable(auditTrail)
+            , fAuditTrail(auditTrail) {
+            fAuditTrail->setClientID(clientID);
         }
 
-        frame->fUniqueID = fUniqueID++;
-        frame->fName = name;
-        fStack.push_back(frame);
-    }
+        ~AutoCollectBatches() { fAuditTrail->setClientID(kInvalidID); }
 
-    void popFrame() {
-        SkASSERT(fEnabled);
-        fStack.pop_back();
-    }
+    private:
+        AutoEnable fAutoEnable;
+        GrAuditTrail* fAuditTrail;
+    };
 
     void addBatch(const char* name, const SkRect& bounds) {
-        SkASSERT(fEnabled && !fStack.empty());
+        SkASSERT(fEnabled);
         Batch* batch = new Batch;
-        fEvents.emplace_back(batch);
-        fStack.back()->fChildren.push_back(batch);
+        fBatchPool.emplace_back(batch);
         batch->fName = name;
         batch->fBounds = bounds;
+        batch->fClientID = kInvalidID;
+        batch->fBatchListID = kInvalidID;
+        batch->fChildID = kInvalidID;
         fCurrentBatch = batch;
+        
+        if (fClientID != kInvalidID) {
+            batch->fClientID = fClientID;
+            Batches** batchesLookup = fClientIDLookup.find(fClientID);
+            Batches* batches = nullptr;
+            if (!batchesLookup) {
+                batches = new Batches;
+                fClientIDLookup.set(fClientID, batches);
+            } else {
+                batches = *batchesLookup;
+            }
+
+            batches->push_back(fCurrentBatch);
+        }
     }
 
     void batchingResultCombined(GrBatch* combiner);
 
     void batchingResultNew(GrBatch* batch);
 
-    SkString toJson(bool batchList = false, bool prettyPrint = false) const;
+    // NOTE these toJson methods only return correct incremental results.
+    // The caller should be somewhat aware of how batching occurs before the results
+    // can be 'trusted'

[ethannicholas, 2016/02/26 20:55:32]

I don't fully understand this comment.

[joshualitt, 2016/02/26 21:08:00]

Sorry, try the comment now.  Basically, you need to know what you are doing when
you call toJson because the results might only be valid for that point in time. 
However, this is algorithm dependent.  The second call below in particular, the
one which takes a clientID, is actually valid for all M where M >= N draws.  I
can explain why this is so, sorry its really confusing and probably a bit
fragile, but I also don't anticipate our reordering algorithm changing very much
if ever.

+    SkString toJson(bool prettyPrint = false) const;
+
+    // returns a json string of all of the batches associated with a given client id
+    SkString toJson(int clientID, bool prettyPrint = false) const;
 
     bool isEnabled() { return fEnabled; }
     void setEnabled(bool enabled) { fEnabled = enabled; }
 
-    void reset() { 
-        SkASSERT(fEnabled && fStack.empty());
-        fFrames.reset();
-    }
-
-    void resetBatchList() {
-        SkASSERT(fEnabled);
-        fBatches.reset();
-        fIDLookup.reset();
-    }
+    void setClientID(int clientID) { fClientID = clientID; }
 
     void fullReset() {
         SkASSERT(fEnabled);
-        this->reset();
-        this->resetBatchList();
-        fEvents.reset(); // must be last, frees all of the memory
+        fBatchList.reset();
+        fIDLookup.reset();
+        // free all client batches
+        fClientIDLookup.foreach([](const int&, Batches** batches) { delete *batches; });
+        fClientIDLookup.reset();
+        fBatchPool.reset(); // must be last, frees all of the memory
     }
 
+    static const int kInvalidID;
+
 private:
     // TODO if performance becomes an issue, we can move to using SkVarAlloc
-    struct Event {
-        virtual ~Event() {}
-        virtual SkString toJson() const=0;
+    struct Batch {
+        SkString toJson() const;
+        SkString fName;
+        SkRect fBounds;
+        int fClientID;
+        int fBatchListID;
+        int fChildID;
+    };
+    typedef SkTArray<SkAutoTDelete<Batch>, true> BatchPool;
 
-        const char* fName;
-        uint64_t fUniqueID;
+    typedef SkTArray<Batch*> Batches;
+
+    struct BatchNode {
+        SkString toJson() const;
+        SkRect fBounds;
+        Batches fChildren;
     };
-
-    struct Frame : public Event {
-        SkString toJson() const override;
-        SkTArray<Event*> fChildren;
-    };
-
-    struct Batch : public Event {
-        SkString toJson() const override;
-        SkRect fBounds;
-        SkTArray<Batch*> fChildren;
-    };
-    typedef SkTArray<SkAutoTDelete<Event>, true> EventArrayPool;
+    typedef SkTArray<SkAutoTDelete<BatchNode>, true> BatchList;
 
     template <typename T>
     static void JsonifyTArray(SkString* json, const char* name, const T& array,
                               bool addComma);
 
-    // We store both an array of frames, and also a flatter array just of the batches
+    Batch* fCurrentBatch;
+    BatchPool fBatchPool;
+    SkTHashMap<GrBatch*, int> fIDLookup;
+    SkTHashMap<int, Batches*> fClientIDLookup;
+    BatchList fBatchList;
+
+    // The client cas pass in an optional client ID which we will use to mark the batches
+    int fClientID;
     bool fEnabled;
-    EventArrayPool fEvents; // manages the lifetimes of the events
-    SkTArray<Event*> fFrames;
-    SkTArray<Frame*> fStack;
-    uint64_t fUniqueID;
-   
-    Batch* fCurrentBatch;
-    SkTHashMap<GrBatch*, int> fIDLookup;
-    SkTArray<Batch*> fBatches;
 };
 
 #define GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, invoke, ...) \
     if (audit_trail->isEnabled()) {                           \
         audit_trail->invoke(__VA_ARGS__);                     \
     }
 
 #define GR_AUDIT_TRAIL_AUTO_FRAME(audit_trail, framename) \
-    GrAuditTrail::AutoFrame SK_MACRO_APPEND_LINE(auto_frame)(audit_trail, framename);
+    // TODO fill out the frame stuff
+    //GrAuditTrail::AutoFrame SK_MACRO_APPEND_LINE(auto_frame)(audit_trail, framename);
 
 #define GR_AUDIT_TRAIL_RESET(audit_trail) \
-    GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, reset);
+    //GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, reset);
 
 #define GR_AUDIT_TRAIL_ADDBATCH(audit_trail, batchname, bounds) \
     GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, addBatch, batchname, bounds);
 
 #define GR_AUDIT_TRAIL_BATCHING_RESULT_COMBINED(audit_trail, combiner) \
     GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, batchingResultCombined, combiner);
 
 #define GR_AUDIT_TRAIL_BATCHING_RESULT_NEW(audit_trail, batch) \
     GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, batchingResultNew, batch);
 
 #endif