Backporting JSONValues from protocol::Values

third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 600 matching lines @@
 
     // Then compare clientDebugName, in alphabetic order.
     int nameCompareResult = codePointCompare(a.clientDebugName, b.clientDebugName);
     if (nameCompareResult != 0)
         return nameCompareResult < 0;
 
     return a.reason < b.reason;
 }
 
 template <typename T>
-static PassRefPtr<JSONArray> pointAsJSONArray(const T& point)
+static std::unique_ptr<JSONArray> pointAsJSONArray(const T& point)
 {
-    RefPtr<JSONArray> array = JSONArray::create();
-    array->pushNumber(point.x());
-    array->pushNumber(point.y());
+    std::unique_ptr<JSONArray> array = JSONArray::create();
+    array->pushDouble(point.x());
+    array->pushDouble(point.y());
     return array;
 }
 
 template <typename T>
-static PassRefPtr<JSONArray> sizeAsJSONArray(const T& size)
+static std::unique_ptr<JSONArray> sizeAsJSONArray(const T& size)
 {
-    RefPtr<JSONArray> array = JSONArray::create();
-    array->pushNumber(size.width());
-    array->pushNumber(size.height());
+    std::unique_ptr<JSONArray> array = JSONArray::create();
+    array->pushDouble(size.width());
+    array->pushDouble(size.height());
     return array;
 }
 
 template <typename T>
-static PassRefPtr<JSONArray> rectAsJSONArray(const T& rect)
+static std::unique_ptr<JSONArray> rectAsJSONArray(const T& rect)
 {
-    RefPtr<JSONArray> array = JSONArray::create();
-    array->pushNumber(rect.x());
-    array->pushNumber(rect.y());
-    array->pushNumber(rect.width());
-    array->pushNumber(rect.height());
+    std::unique_ptr<JSONArray> array = JSONArray::create();
+    array->pushDouble(rect.x());
+    array->pushDouble(rect.y());
+    array->pushDouble(rect.width());
+    array->pushDouble(rect.height());
     return array;
 }
 
 static double roundCloseToZero(double number)
 {
     return std::abs(number) < 1e-7 ? 0 : number;
 }
 
-static PassRefPtr<JSONArray> transformAsJSONArray(const TransformationMatrix& t)
+static std::unique_ptr<JSONArray> transformAsJSONArray(const TransformationMatrix& t)
 {
-    RefPtr<JSONArray> array = JSONArray::create();
+    std::unique_ptr<JSONArray> array = JSONArray::create();
     {
-        RefPtr<JSONArray> row = JSONArray::create();
-        row->pushNumber(roundCloseToZero(t.m11()));
-        row->pushNumber(roundCloseToZero(t.m12()));
-        row->pushNumber(roundCloseToZero(t.m13()));
-        row->pushNumber(roundCloseToZero(t.m14()));
-        array->pushArray(row);
+        std::unique_ptr<JSONArray> row = JSONArray::create();
+        row->pushDouble(roundCloseToZero(t.m11()));
+        row->pushDouble(roundCloseToZero(t.m12()));
+        row->pushDouble(roundCloseToZero(t.m13()));
+        row->pushDouble(roundCloseToZero(t.m14()));
+        array->pushArray(std::move(row));
     }
     {
-        RefPtr<JSONArray> row = JSONArray::create();
-        row->pushNumber(roundCloseToZero(t.m21()));
-        row->pushNumber(roundCloseToZero(t.m22()));
-        row->pushNumber(roundCloseToZero(t.m23()));
-        row->pushNumber(roundCloseToZero(t.m24()));
-        array->pushArray(row);
+        std::unique_ptr<JSONArray> row = JSONArray::create();
+        row->pushDouble(roundCloseToZero(t.m21()));
+        row->pushDouble(roundCloseToZero(t.m22()));
+        row->pushDouble(roundCloseToZero(t.m23()));
+        row->pushDouble(roundCloseToZero(t.m24()));
+        array->pushArray(std::move(row));
     }
     {
-        RefPtr<JSONArray> row = JSONArray::create();
-        row->pushNumber(roundCloseToZero(t.m31()));
-        row->pushNumber(roundCloseToZero(t.m32()));
-        row->pushNumber(roundCloseToZero(t.m33()));
-        row->pushNumber(roundCloseToZero(t.m34()));
-        array->pushArray(row);
+        std::unique_ptr<JSONArray> row = JSONArray::create();
+        row->pushDouble(roundCloseToZero(t.m31()));
+        row->pushDouble(roundCloseToZero(t.m32()));
+        row->pushDouble(roundCloseToZero(t.m33()));
+        row->pushDouble(roundCloseToZero(t.m34()));
+        array->pushArray(std::move(row));
     }
     {
-        RefPtr<JSONArray> row = JSONArray::create();
-        row->pushNumber(roundCloseToZero(t.m41()));
-        row->pushNumber(roundCloseToZero(t.m42()));
-        row->pushNumber(roundCloseToZero(t.m43()));
-        row->pushNumber(roundCloseToZero(t.m44()));
-        array->pushArray(row);
+        std::unique_ptr<JSONArray> row = JSONArray::create();
+        row->pushDouble(roundCloseToZero(t.m41()));
+        row->pushDouble(roundCloseToZero(t.m42()));
+        row->pushDouble(roundCloseToZero(t.m43()));
+        row->pushDouble(roundCloseToZero(t.m44()));
+        array->pushArray(std::move(row));
     }
     return array;
 }
 
 static String pointerAsString(const void* ptr)
 {
     TextStream ts;
     ts << ptr;
     return ts.release();
 }
 
-PassRefPtr<JSONObject> GraphicsLayer::layerTreeAsJSON(LayerTreeFlags flags) const
+std::unique_ptr<JSONObject> GraphicsLayer::layerTreeAsJSON(LayerTreeFlags flags) const
 {
     RenderingContextMap renderingContextMap;
     return layerTreeAsJSONInternal(flags, renderingContextMap);
 }
 
-PassRefPtr<JSONObject> GraphicsLayer::layerTreeAsJSONInternal(LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
+std::unique_ptr<JSONObject> GraphicsLayer::layerTreeAsJSONInternal(LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
 {
-    RefPtr<JSONObject> json = JSONObject::create();
+    std::unique_ptr<JSONObject> json = JSONObject::create();
 
     if (flags & LayerTreeIncludesDebugInfo)
         json->setString("this", pointerAsString(this));
 
     json->setString("name", debugName());
 
     if (m_position != FloatPoint())
         json->setArray("position", pointAsJSONArray(m_position));
 
     if (m_hasTransformOrigin && m_transformOrigin != FloatPoint3D(m_size.width() * 0.5f, m_size.height() * 0.5f, 0))
         json->setArray("transformOrigin", pointAsJSONArray(m_transformOrigin));
 
     if (m_size != IntSize())
         json->setArray("bounds", sizeAsJSONArray(m_size));
 
     if (m_opacity != 1)
-        json->setNumber("opacity", m_opacity);
+        json->setDouble("opacity", m_opacity);
 
     if (m_blendMode != WebBlendModeNormal)
         json->setString("blendMode", compositeOperatorName(CompositeSourceOver, m_blendMode));
 
     if (m_isRootForIsolatedGroup)
         json->setBoolean("isolate", m_isRootForIsolatedGroup);
 
     if (m_contentsOpaque)
         json->setBoolean("contentsOpaque", m_contentsOpaque);
 
     if (!m_shouldFlattenTransform)
         json->setBoolean("shouldFlattenTransform", m_shouldFlattenTransform);
 
     if (m_3dRenderingContext) {
         RenderingContextMap::const_iterator it = renderingContextMap.find(m_3dRenderingContext);
         int contextId = renderingContextMap.size() + 1;
         if (it == renderingContextMap.end())
             renderingContextMap.set(m_3dRenderingContext, contextId);
         else
             contextId = it->value;
 
-        json->setNumber("3dRenderingContext", contextId);
+        json->setInteger("3dRenderingContext", contextId);
     }
 
     if (m_drawsContent)
         json->setBoolean("drawsContent", m_drawsContent);
 
     if (!m_contentsVisible)
         json->setBoolean("contentsVisible", m_contentsVisible);
 
     if (!m_backfaceVisibility)
         json->setString("backfaceVisibility", m_backfaceVisibility ? "visible" : "hidden");
@@ skipping 12 matching lines @@
 
     if (m_replicatedLayer)
         json->setString("replicatedLayer", flags & LayerTreeIncludesDebugInfo ? pointerAsString(m_replicatedLayer) : "");
 
     PaintInvalidationTrackingMap::iterator it = paintInvalidationTrackingMap().find(this);
     if (it != paintInvalidationTrackingMap().end()) {
         if (flags & LayerTreeIncludesPaintInvalidations) {
             Vector<PaintInvalidationInfo>& infos = it->value.trackedPaintInvalidations;
             if (!infos.isEmpty()) {
                 std::sort(infos.begin(), infos.end(), &comparePaintInvalidationInfo);
-                RefPtr<JSONArray> paintInvalidationsJSON = JSONArray::create();
+                std::unique_ptr<JSONArray> paintInvalidationsJSON = JSONArray::create();
                 for (auto& info : infos) {
-                    RefPtr<JSONObject> infoJSON = JSONObject::create();
+                    std::unique_ptr<JSONObject> infoJSON = JSONObject::create();
                     infoJSON->setString("object", info.clientDebugName);
                     if (!info.rect.isEmpty())
                         infoJSON->setArray("rect", rectAsJSONArray(info.rect));
                     infoJSON->setString("reason", paintInvalidationReasonToString(info.reason));
-                    paintInvalidationsJSON->pushObject(infoJSON);
+                    paintInvalidationsJSON->pushObject(std::move(infoJSON));
                 }
-                json->setArray("paintInvalidations", paintInvalidationsJSON);
+                json->setArray("paintInvalidations", std::move(paintInvalidationsJSON));
             }
 #if DCHECK_IS_ON()
             Vector<UnderPaintInvalidation>& underPaintInvalidations = it->value.underPaintInvalidations;
             if (!underPaintInvalidations.isEmpty()) {
-                RefPtr<JSONArray> underPaintInvalidationsJSON = JSONArray::create();
+                std::unique_ptr<JSONArray> underPaintInvalidationsJSON = JSONArray::create();
                 for (auto& underPaintInvalidation : underPaintInvalidations) {
-                    RefPtr<JSONObject> underPaintInvalidationJSON = JSONObject::create();
-                    underPaintInvalidationJSON->setNumber("x", underPaintInvalidation.x);
-                    underPaintInvalidationJSON->setNumber("y", underPaintInvalidation.x);
+                    std::unique_ptr<JSONObject> underPaintInvalidationJSON = JSONObject::create();
+                    underPaintInvalidationJSON->setDouble("x", underPaintInvalidation.x);
+                    underPaintInvalidationJSON->setDouble("y", underPaintInvalidation.x);
                     underPaintInvalidationJSON->setString("oldPixel", Color(underPaintInvalidation.oldPixel).nameForLayoutTreeAsText());
                     underPaintInvalidationJSON->setString("newPixel", Color(underPaintInvalidation.newPixel).nameForLayoutTreeAsText());
-                    underPaintInvalidationsJSON->pushObject(underPaintInvalidationJSON);
+                    underPaintInvalidationsJSON->pushObject(std::move(underPaintInvalidationJSON));
                 }
-                json->setArray("underPaintInvalidations", underPaintInvalidationsJSON);
+                json->setArray("underPaintInvalidations", std::move(underPaintInvalidationsJSON));
             }
 #endif
         }
     }
 
     if ((flags & LayerTreeIncludesPaintingPhases) && m_paintingPhase) {
-        RefPtr<JSONArray> paintingPhasesJSON = JSONArray::create();
+        std::unique_ptr<JSONArray> paintingPhasesJSON = JSONArray::create();
         if (m_paintingPhase & GraphicsLayerPaintBackground)
             paintingPhasesJSON->pushString("GraphicsLayerPaintBackground");
         if (m_paintingPhase & GraphicsLayerPaintForeground)
             paintingPhasesJSON->pushString("GraphicsLayerPaintForeground");
         if (m_paintingPhase & GraphicsLayerPaintMask)
             paintingPhasesJSON->pushString("GraphicsLayerPaintMask");
         if (m_paintingPhase & GraphicsLayerPaintChildClippingMask)
             paintingPhasesJSON->pushString("GraphicsLayerPaintChildClippingMask");
         if (m_paintingPhase & GraphicsLayerPaintOverflowContents)
             paintingPhasesJSON->pushString("GraphicsLayerPaintOverflowContents");
         if (m_paintingPhase & GraphicsLayerPaintCompositedScroll)
             paintingPhasesJSON->pushString("GraphicsLayerPaintCompositedScroll");
-        json->setArray("paintingPhases", paintingPhasesJSON);
+        json->setArray("paintingPhases", std::move(paintingPhasesJSON));
     }
 
     if (flags & LayerTreeIncludesClipAndScrollParents) {
         if (m_hasScrollParent)
             json->setBoolean("hasScrollParent", true);
         if (m_hasClipParent)
             json->setBoolean("hasClipParent", true);
     }
 
     if (flags & (LayerTreeIncludesDebugInfo | LayerTreeIncludesCompositingReasons)) {
         bool debug = flags & LayerTreeIncludesDebugInfo;
-        RefPtr<JSONArray> compositingReasonsJSON = JSONArray::create();
+        std::unique_ptr<JSONArray> compositingReasonsJSON = JSONArray::create();
         for (size_t i = 0; i < kNumberOfCompositingReasons; ++i) {
             if (m_debugInfo.getCompositingReasons() & kCompositingReasonStringMap[i].reason)
                 compositingReasonsJSON->pushString(debug ? kCompositingReasonStringMap[i].description : kCompositingReasonStringMap[i].shortName);
         }
-        json->setArray("compositingReasons", compositingReasonsJSON);
+        json->setArray("compositingReasons", std::move(compositingReasonsJSON));
 
-        RefPtr<JSONArray> squashingDisallowedReasonsJSON = JSONArray::create();
+        std::unique_ptr<JSONArray> squashingDisallowedReasonsJSON = JSONArray::create();
         for (size_t i = 0; i < kNumberOfSquashingDisallowedReasons; ++i) {
             if (m_debugInfo.getSquashingDisallowedReasons() & kSquashingDisallowedReasonStringMap[i].reason)
                 squashingDisallowedReasonsJSON->pushString(debug ? kSquashingDisallowedReasonStringMap[i].description : kSquashingDisallowedReasonStringMap[i].shortName);
         }
-        json->setArray("squashingDisallowedReasons", squashingDisallowedReasonsJSON);
+        json->setArray("squashingDisallowedReasons", std::move(squashingDisallowedReasonsJSON));
     }
 
     if (m_children.size()) {
-        RefPtr<JSONArray> childrenJSON = JSONArray::create();
+        std::unique_ptr<JSONArray> childrenJSON = JSONArray::create();
         for (size_t i = 0; i < m_children.size(); i++)
             childrenJSON->pushObject(m_children[i]->layerTreeAsJSONInternal(flags, renderingContextMap));
-        json->setArray("children", childrenJSON);
+        json->setArray("children", std::move(childrenJSON));
     }
 
     return json;
 }
 
 String GraphicsLayer::layerTreeAsText(LayerTreeFlags flags) const
 {
     return layerTreeAsJSON(flags)->toPrettyJSONString();
 }
 
@@ skipping 494 matching lines @@
 {
     if (!layer) {
         fprintf(stderr, "Cannot showGraphicsLayerTree for (nil).\n");
         return;
     }
 
     String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
     fprintf(stderr, "%s\n", output.utf8().data());
 }
 #endif