Introduce builders for tracing event arguments

Source/platform/TracedValue.cpp

 // 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.
 
 #include "config.h"
 
 #include "platform/TracedValue.h"
 
 #include "platform/JSONValues.h"
 
 namespace WebCore {
 
-TracedValue::TracedValue(PassRefPtr<JSONValue> value)
-    : m_value(value)
+namespace {
+
+class ConvertibleToTraceFormatJSONValue : public TraceEvent::ConvertableToTraceFormat {
+    WTF_MAKE_NONCOPYABLE(ConvertibleToTraceFormatJSONValue);
+public:
+    explicit ConvertibleToTraceFormatJSONValue(PassRefPtr<JSONValue> value) : m_value(value) { }
+    virtual String asTraceFormat() const OVERRIDE
+    {
+        return m_value->toJSONString();
+    }
+
+private:
+    virtual ~ConvertibleToTraceFormatJSONValue() { }
+
+    RefPtr<JSONValue> m_value;
+};
+
+String threadSafeCopy(const String& string)
+{
+    RefPtr<StringImpl> copy(string.impl());
+    if (string.isSafeToSendToAnotherThread())
+        return string;
+    return string.isolatedCopy();
+}
+
+#ifdef ASSERT_ENABLED
+bool isJSONObject(JSONValue* value)

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

I think explicitly comparing against value->type() is more readable and can be
conveniently inlined.

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

Good point. I forgot that we have type getter.

+{
+    RefPtr<JSONObject> object;
+    return value->asObject(&object);
+}
+bool isJSONArray(JSONValue* value)
+{
+    RefPtr<JSONArray> array;
+    return value->asArray(&array);
+}
+#endif
+
+}
+
+TracedValueBase::TracedValueBase()
 {
 }
 
-String TracedValue::asTraceFormat() const
+TracedValueBase::~TracedValueBase()
 {
-    return m_value->toJSONString();
+}
+
+void TracedValueBase::setInteger(const char* name, int value)
+{
+    currentDictionary()->setNumber(name, value);
+}
+
+void TracedValueBase::setDouble(const char* name, double value)
+{
+    currentDictionary()->setNumber(name, value);
+}
+
+void TracedValueBase::setBoolean(const char* name, bool value)
+{
+    currentDictionary()->setBoolean(name, value);
+}
+
+void TracedValueBase::setString(const char* name, const String& value)
+{
+    currentDictionary()->setString(name, threadSafeCopy(value));
+}
+
+void TracedValueBase::beginDictionaryNamed(const char* name)
+{
+    RefPtr<JSONObject> dictionary = JSONObject::create();
+    currentDictionary()->setObject(name, dictionary);
+    m_stack.append(dictionary);
+}
+
+void TracedValueBase::beginArrayNamed(const char* name)
+{
+    RefPtr<JSONArray> array = JSONArray::create();
+    currentDictionary()->setArray(name, array);
+    m_stack.append(array);
+}
+
+void TracedValueBase::endCurrentDictionary()
+{
+    ASSERT(m_stack.size() > 1);
+    ASSERT(currentDictionary());
+    m_stack.removeLast();
+}
+
+void TracedValueBase::pushInteger(int value)
+{
+    currentArray()->pushInt(value);
+}
+
+void TracedValueBase::pushDouble(double value)
+{
+    currentArray()->pushNumber(value);
+}
+
+void TracedValueBase::pushBoolean(bool value)
+{
+    currentArray()->pushBoolean(value);
+}
+
+void TracedValueBase::pushString(const String& value)
+{
+    currentArray()->pushString(threadSafeCopy(value));
+}
+
+void TracedValueBase::pushArray()
+{
+    RefPtr<JSONArray> array = JSONArray::create();
+    currentArray()->pushArray(array);
+    m_stack.append(array);
+}
+
+void TracedValueBase::pushDictionary()
+{
+    RefPtr<JSONObject> dictionary = JSONObject::create();
+    currentArray()->pushObject(dictionary);
+    m_stack.append(dictionary);
+}
+
+void TracedValueBase::endCurrentArray()
+{
+    ASSERT(m_stack.size() > 1);
+    ASSERT(currentArray());
+    m_stack.removeLast();
+}
+
+JSONObject* TracedValueBase::currentDictionary() const
+{
+    ASSERT(!m_stack.isEmpty());
+    ASSERT(isJSONObject(m_stack.last().get()));
+    return static_cast<JSONObject*>(m_stack.last().get());
+}
+
+JSONArray* TracedValueBase::currentArray() const
+{
+    ASSERT(!m_stack.isEmpty());
+    ASSERT(isJSONArray(m_stack.last().get()));
+    return static_cast<JSONArray*>(m_stack.last().get());
+}
+
+TracedValue::TracedValue()
+{
+    m_stack.append(JSONObject::create());
 }
 
 TracedValue::~TracedValue()
 {
+    ASSERT(m_stack.isEmpty());
+}
+
+TracedDictionary<TracedValue>& TracedValue::beginDictionary(const char* name)
+{
+    beginDictionaryNamed(name);
+    return *reinterpret_cast<TracedDictionary<TracedValue>* >(this);
+}
+
+TracedArray<TracedValue>& TracedValue::beginArray(const char* name)
+{
+    beginArrayNamed(name);
+    return *reinterpret_cast<TracedArray<TracedValue>* >(this);
+}
+
+PassRefPtr<TraceEvent::ConvertableToTraceFormat> TracedValue::finish()
+{
+    ASSERT(m_stack.size() == 1);
+    RefPtr<JSONValue> value(currentDictionary());
+    m_stack.clear();
+    return adoptRef(new ConvertibleToTraceFormatJSONValue(value));
 }
 
 }