Support single line objects and arrays

This is just a formatting nicety. The new caps dump has several large
arrays of structs, and keeping each object on one line makes them much
more readable. (It also limits the total length of the output, which
helps when scanning through).

Example of the output, before and after this change:
https://gist.github.com/brianosman/872f33be9af49031023b791e7db0b1fb

Bug: skia:
Change-Id: I0fe0c2241b0c7f451b0837500e554d0491126d5e
Reviewed-on: https://skia-review.googlesource.com/32820
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>

src/gpu/GrCaps.cpp

@@ -193,7 +193,7 @@ void GrCaps::dumpJSON(SkJSONWriter* writer) const {
 
     for (size_t i = 1; i < kGrPixelConfigCnt; ++i) {
         GrPixelConfig config = static_cast<GrPixelConfig>(i);
-        writer->beginObject();
+        writer->beginObject(nullptr, false);
         writer->appendString("name", pixel_config_name(config));
         writer->appendBool("renderable", this->isConfigRenderable(config, false));
         writer->appendBool("renderableMSAA", this->isConfigRenderable(config, true));

src/gpu/GrShaderCaps.cpp

@@ -117,7 +117,7 @@ void GrShaderCaps::dumpJSON(SkJSONWriter* writer) const {
         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             if (fFloatPrecisions[s][p].supported()) {
                 GrSLPrecision precision = static_cast<GrSLPrecision>(p);
-                writer->beginObject();
+                writer->beginObject(nullptr, false);
                 writer->appendString("precision", precision_to_string(precision));
                 writer->appendS32("log_low", fFloatPrecisions[s][p].fLogRangeLow);
                 writer->appendS32("log_high", fFloatPrecisions[s][p].fLogRangeHigh);

src/gpu/gl/GrGLCaps.cpp

@@ -1258,7 +1258,7 @@ void GrGLCaps::onDumpJSON(SkJSONWriter* writer) const {
     writer->beginArray("Stencil Formats");
 
     for (int i = 0; i < fStencilFormats.count(); ++i) {
-        writer->beginObject();
+        writer->beginObject(nullptr, false);
         writer->appendS32("stencil bits", fStencilFormats[i].fStencilBits);
         writer->appendS32("total bits", fStencilFormats[i].fTotalBits);
         writer->endObject();
@@ -1339,7 +1339,7 @@ void GrGLCaps::onDumpJSON(SkJSONWriter* writer) const {
     writer->beginArray("configs");
 
     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
-        writer->beginObject();
+        writer->beginObject(nullptr, false);
         writer->appendHexU32("flags", fConfigTable[i].fFlags);
         writer->appendHexU32("b_internal", fConfigTable[i].fFormats.fBaseInternalFormat);
         writer->appendHexU32("s_internal", fConfigTable[i].fFormats.fSizedInternalFormat);

src/utils/SkJSONWriter.h

@@ -54,12 +54,14 @@ public:
             , fMode(mode)
             , fState(State::kStart) {
         fScopeStack.push_back(Scope::kNone);
+        fNewlineStack.push_back(true);
     }
 
     ~SkJSONWriter() {
         this->flush();
         delete[] fBlock;
         SkASSERT(fScopeStack.count() == 1);
+        SkASSERT(fNewlineStack.count() == 1);
     }
 
     /**
@@ -86,7 +88,7 @@ public:
         if (State::kObjectValue == fState) {
             this->write(",", 1);
         }
-        this->newline();
+        this->separator(this->multiline());
         this->write("\"", 1);
         this->write(name, strlen(name));
         this->write("\":", 2);
@@ -96,12 +98,17 @@ public:
     /**
      *  Adds a new object. A name must be supplied when called between beginObject() and
      *  endObject(). Calls to beginObject() must be balanced by corresponding calls to endObject().
+     *  By default, objects are written out with one named value per line (when in kPretty mode).
+     *  This can be overridden for a particular object by passing false for multiline, this will
+     *  keep the entire object on a single line. This can help with readability in some situations.
+     *  In kFast mode, this parameter is ignored.
      */
-    void beginObject(const char* name = nullptr) {
+    void beginObject(const char* name = nullptr, bool multiline = true) {
         this->appendName(name);
         this->beginValue(true);
         this->write("{", 1);
         fScopeStack.push_back(Scope::kObject);
+        fNewlineStack.push_back(multiline);
         fState = State::kObjectBegin;
     }
 
@@ -112,9 +119,10 @@ public:
         SkASSERT(Scope::kObject == this->scope());
         SkASSERT(State::kObjectBegin == fState || State::kObjectValue == fState);
         bool emptyObject = State::kObjectBegin == fState;
+        bool wasMultiline = this->multiline();
         this->popScope();
         if (!emptyObject) {
-            this->newline();
+            this->separator(wasMultiline);
         }
         this->write("}", 1);
     }
@@ -122,12 +130,17 @@ public:
     /**
      *  Adds a new array. A name must be supplied when called between beginObject() and
      *  endObject(). Calls to beginArray() must be balanced by corresponding calls to endArray().
+     *  By default, arrays are written out with one value per line (when in kPretty mode).
+     *  This can be overridden for a particular array by passing false for multiline, this will
+     *  keep the entire array on a single line. This can help with readability in some situations.
+     *  In kFast mode, this parameter is ignored.
      */
-    void beginArray(const char* name = nullptr) {
+    void beginArray(const char* name = nullptr, bool multiline = true) {
         this->appendName(name);
         this->beginValue(true);
         this->write("[", 1);
         fScopeStack.push_back(Scope::kArray);
+        fNewlineStack.push_back(multiline);
         fState = State::kArrayBegin;
     }
 
@@ -138,9 +151,10 @@ public:
         SkASSERT(Scope::kArray == this->scope());
         SkASSERT(State::kArrayBegin == fState || State::kArrayValue == fState);
         bool emptyArray = State::kArrayBegin == fState;
+        bool wasMultiline = this->multiline();
         this->popScope();
         if (!emptyArray) {
-            this->newline();
+            this->separator(wasMultiline);
         }
         this->write("]", 1);
     }
@@ -259,7 +273,7 @@ private:
             this->write(",", 1);
         }
         if (Scope::kArray == this->scope()) {
-            this->newline();
+            this->separator(this->multiline());
         } else if (Scope::kObject == this->scope() && Mode::kPretty == fMode) {
             this->write(" ", 1);
         }
@@ -270,11 +284,15 @@ private:
         }
     }
 
-    void newline() {
+    void separator(bool multiline) {
         if (Mode::kPretty == fMode) {
-            this->write("\n", 1);
-            for (int i = 0; i < fScopeStack.count() - 1; ++i) {
-                this->write("   ", 3);
+            if (multiline) {
+                this->write("\n", 1);
+                for (int i = 0; i < fScopeStack.count() - 1; ++i) {
+                    this->write("   ", 3);
+                }
+            } else {
+                this->write(" ", 1);
             }
         }
     }
@@ -298,8 +316,14 @@ private:
         return fScopeStack.back();
     }
 
+    bool multiline() const {
+        SkASSERT(!fNewlineStack.empty());
+        return fNewlineStack.back();
+    }
+
     void popScope() {
         fScopeStack.pop_back();
+        fNewlineStack.pop_back();
         switch (this->scope()) {
             case Scope::kNone:
                 fState = State::kEnd;
@@ -324,6 +348,7 @@ private:
     Mode fMode;
     State fState;
     SkSTArray<16, Scope, true> fScopeStack;
+    SkSTArray<16, bool, true> fNewlineStack;
 };
 
 #endif