Introduce builders for tracing event arguments

Source/platform/TracedValue.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef TracedValue_h
 #define TracedValue_h
 
 #include "platform/EventTracer.h"
 
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
+class JSONArray;
+class JSONObject;
 class JSONValue;
+template<class T> class TracedArray;
 
-class PLATFORM_EXPORT TracedValue : public TraceEvent::ConvertableToTraceFormat {
+class PLATFORM_EXPORT TracedValueBase {
+    WTF_MAKE_NONCOPYABLE(TracedValueBase);
+protected:
+    TracedValueBase();
+    ~TracedValueBase();
+
+    void setInteger(const char* name, int value);

[caseq, 2014/06/25 14:27:25]

Can we put these methods on TracedDictionary...

[yurys, 2014/06/25 14:57:40]

TracedDictionary is a template which means that these methods would be
duplicated for each instantiation.

+    void setDouble(const char* name, double);
+    void setBoolean(const char* name, bool value);
+    void setString(const char* name, const String& value);
+    void beginDictionaryNamed(const char* name);
+    void beginArrayNamed(const char* name);
+    void endCurrentDictionary();
+
+    void pushInteger(int);

[caseq, 2014/06/25 14:27:25]

... and these to TracedArray instead?

[yurys, 2014/06/25 14:57:40]

I'd like to avoid this for the same reason as above. Alternatively we could have
intermediate non-template TracedDictionaryBase and TracedArrayBase that would
contain these methods. It looks like unnecessary complication though and since
this is an implementation detail I'd rather keep things as is.

+    void pushDouble(double);
+    void pushBoolean(bool);
+    void pushString(const String&);
+    void pushArray();
+    void pushDictionary();
+    void endCurrentArray();
+
+    JSONObject* currentDictionary() const;
+    JSONArray* currentArray() const;
+
+    Vector<RefPtr<JSONValue> > m_stack;
+};
+
+template <class OwnerType>
+class PLATFORM_EXPORT TracedDictionary : public TracedValueBase {
+    WTF_MAKE_NONCOPYABLE(TracedDictionary);
+public:
+    OwnerType& endDictionary()
+    {
+        endCurrentDictionary();
+        return *reinterpret_cast<OwnerType*>(this);
+    }
+
+    TracedDictionary<TracedDictionary<OwnerType> >& beginDictionary(const char* name)
+    {
+        beginDictionaryNamed(name);
+        return *reinterpret_cast<TracedDictionary<TracedDictionary<OwnerType> >* >(this);
+    }
+    TracedArray<TracedDictionary<OwnerType> >& beginArray(const char* name)
+    {
+        beginArrayNamed(name);
+        return *reinterpret_cast<TracedArray<TracedDictionary<OwnerType> >* >(this);
+    }
+    TracedDictionary<OwnerType>& setInteger(const char* name, int value)
+    {
+        TracedValueBase::setInteger(name, value);
+        return *this;
+    }
+    TracedDictionary<OwnerType>& setDouble(const char* name, double value)
+    {
+        TracedValueBase::setDouble(name, value);
+        return *this;
+    }
+    TracedDictionary<OwnerType>& setBoolean(const char* name, bool value)
+    {
+        TracedValueBase::setBoolean(name, value);
+        return *this;
+    }
+    TracedDictionary<OwnerType>& setString(const char* name, const String& value)
+    {
+        TracedValueBase::setString(name, value);
+        return *this;
+    }
+
+private:
+    TracedDictionary();
+    ~TracedDictionary();
+};
+
+template <class OwnerType>
+class PLATFORM_EXPORT TracedArray : public TracedValueBase {
+    WTF_MAKE_NONCOPYABLE(TracedArray);
+public:
+    TracedDictionary<TracedArray<OwnerType> >& beginDictionary()
+    {
+        pushDictionary();
+        return *reinterpret_cast<TracedDictionary<TracedArray<OwnerType> >* >(this);
+    }
+    TracedDictionary<TracedArray<OwnerType> >& beginArray()
+    {
+        pushArray();
+        return *reinterpret_cast<TracedDictionary<TracedArray<OwnerType> >* >(this);
+    }
+    OwnerType& endArray()
+    {
+        endCurrentArray();
+        return *reinterpret_cast<OwnerType*>(this);
+    }
+
+    TracedArray<OwnerType>& pushInteger(int value)
+    {
+        TracedValueBase::pushInteger(value);
+        return *this;
+    }
+    TracedArray<OwnerType>& pushDouble(double value)
+    {
+        TracedValueBase::pushDouble(value);
+        return *this;
+    }
+    TracedArray<OwnerType>& pushBoolean(bool value)
+    {
+        TracedValueBase::pushBoolean(value);
+        return *this;
+    }
+    TracedArray<OwnerType>& pushString(const String& value)
+    {
+        TracedValueBase::pushString(value);
+        return *this;
+    }
+
+private:
+    TracedArray();
+    ~TracedArray();
+};
+
+class PLATFORM_EXPORT TracedValue : public TracedValueBase {

[caseq, 2014/06/25 14:27:25]

Can we inherit from TracedDictionary instead?

[yurys, 2014/06/25 14:57:40]

I don't think so it has different implementation of  beginDictionary, beginArray
and provides endDictionary.

     WTF_MAKE_NONCOPYABLE(TracedValue);
 public:
-    static PassRefPtr<TraceEvent::ConvertableToTraceFormat> fromJSONValue(PassRefPtr<JSONValue> value)
+    TracedValue();
+    ~TracedValue();
+
+    TracedDictionary<TracedValue>& beginDictionary(const char* name);
+    TracedArray<TracedValue>& beginArray(const char* name);
+    TracedValue& setInteger(const char* name, int value)
     {
-        return adoptRef(new TracedValue(value));
+        TracedValueBase::setInteger(name, value);
+        return *this;
     }
-
-    String asTraceFormat() const OVERRIDE;
-
-private:
-    explicit TracedValue(PassRefPtr<JSONValue>);
-    virtual ~TracedValue();
-
-    RefPtr<JSONValue> m_value;
+    TracedValue& setDouble(const char* name, double value)
+    {
+        TracedValueBase::setDouble(name, value);
+        return *this;
+    }
+    TracedValue& setBoolean(const char* name, bool value)
+    {
+        TracedValueBase::setBoolean(name, value);
+        return *this;
+    }
+    TracedValue& setString(const char* name, const String& value)
+    {
+        TracedValueBase::setString(name, value);
+        return *this;
+    }
+    PassRefPtr<TraceEvent::ConvertableToTraceFormat> finish();
 };
 
 } // namespace WebCore
 
 #endif // TracedValue_h