Non-template base classes for TracedArray and TracedDictionary.

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;
+class TracedArrayBase;
 template<class T> class TracedArray;
 
 class PLATFORM_EXPORT TracedValueBase {
     WTF_MAKE_NONCOPYABLE(TracedValueBase);
 protected:
     TracedValueBase();
     ~TracedValueBase();
 
     void setInteger(const char* name, int value);
     void setDouble(const char* name, double);
@@ skipping 10 matching lines @@
     void pushArray();
     void pushDictionary();
     void endCurrentArray();
 
     JSONObject* currentDictionary() const;
     JSONArray* currentArray() const;
 
     Vector<RefPtr<JSONValue> > m_stack;
 };
 
+class TracedDictionaryBase : public TracedValueBase {
+    WTF_MAKE_NONCOPYABLE(TracedDictionaryBase);
+public:
+    void endDictionary()
+    {
+        endCurrentDictionary();
+    }
+
+    TracedDictionaryBase& beginDictionary(const char* name)
+    {
+        beginDictionaryNamed(name);
+        return *this;
+    }
+    TracedArrayBase& beginArray(const char* name)
+    {
+        beginArrayNamed(name);
+        return *reinterpret_cast<TracedArrayBase*>(this);
+    }
+    TracedDictionaryBase& setInteger(const char* name, int value)
+    {
+        TracedValueBase::setInteger(name, value);
+        return *this;
+    }
+    TracedDictionaryBase& setDouble(const char* name, double value)
+    {
+        TracedValueBase::setDouble(name, value);
+        return *this;
+    }
+    TracedDictionaryBase& setBoolean(const char* name, bool value)
+    {
+        TracedValueBase::setBoolean(name, value);
+        return *this;
+    }
+    TracedDictionaryBase& setString(const char* name, const String& value)
+    {
+        TracedValueBase::setString(name, value);
+        return *this;
+    }
+private:
+    TracedDictionaryBase();
+    ~TracedDictionaryBase();
+};
+
 template <class OwnerType>
-class TracedDictionary : public TracedValueBase {
+class TracedDictionary : public TracedDictionaryBase {
     WTF_MAKE_NONCOPYABLE(TracedDictionary);
 public:
     OwnerType& endDictionary()
     {
         ASSERT(m_stack.size() == nestingLevel);
-        endCurrentDictionary();
+        TracedDictionaryBase::endDictionary();
         return *reinterpret_cast<OwnerType*>(this);
     }
 
     TracedDictionary<TracedDictionary<OwnerType> >& beginDictionary(const char* name)
     {
-        beginDictionaryNamed(name);
+        TracedDictionaryBase::beginDictionary(name);
         return *reinterpret_cast<TracedDictionary<TracedDictionary<OwnerType> >* >(this);
     }
     TracedArray<TracedDictionary<OwnerType> >& beginArray(const char* name)
     {
-        beginArrayNamed(name);
+        TracedDictionaryBase::beginArray(name);
         return *reinterpret_cast<TracedArray<TracedDictionary<OwnerType> >* >(this);
     }
     TracedDictionary<OwnerType>& setInteger(const char* name, int value)
     {
-        TracedValueBase::setInteger(name, value);
+        TracedDictionaryBase::setInteger(name, value);
         return *this;
     }
     TracedDictionary<OwnerType>& setDouble(const char* name, double value)
     {
-        TracedValueBase::setDouble(name, value);
+        TracedDictionaryBase::setDouble(name, value);
         return *this;
     }
     TracedDictionary<OwnerType>& setBoolean(const char* name, bool value)
     {
-        TracedValueBase::setBoolean(name, value);
+        TracedDictionaryBase::setBoolean(name, value);
         return *this;
     }
     TracedDictionary<OwnerType>& setString(const char* name, const String& value)
     {
-        TracedValueBase::setString(name, value);
+        TracedDictionaryBase::setString(name, value);
         return *this;
     }
 
     static const size_t nestingLevel = OwnerType::nestingLevel + 1;
 
 private:
     TracedDictionary();
     ~TracedDictionary();
 };
 
+class TracedArrayBase : public TracedValueBase {
+    WTF_MAKE_NONCOPYABLE(TracedArrayBase);
+public:
+    TracedDictionaryBase& beginDictionary()

[alph, 2014/07/10 14:45:22]

You could return TracedDictionary<TracedArrayBase> at his point instead.

This will allow you to temporary forget the current context and pass the
contextless dictionary to a function that does not need to know about the
context. The function in turn may still continue adding contexts if it needs to.

wdyt?

Note that you need to adjust the nestingLevel checks though, as these become
dynamic.

[yurys, 2014/07/10 15:14:07]

Sounds good to me too. It would help to resolve the issue with modular
programming.

+    {
+        pushDictionary();
+        return *reinterpret_cast<TracedDictionaryBase*>(this);
+    }
+    TracedArrayBase& beginArray()
+    {
+        pushArray();
+        return *this;
+    }
+    void endArray()
+    {
+        endCurrentArray();
+    }
+
+    TracedArrayBase& pushInteger(int value)
+    {
+        TracedValueBase::pushInteger(value);
+        return *this;
+    }
+    TracedArrayBase& pushDouble(double value)
+    {
+        TracedValueBase::pushDouble(value);
+        return *this;
+    }
+    TracedArrayBase& pushBoolean(bool value)
+    {
+        TracedValueBase::pushBoolean(value);
+        return *this;
+    }
+    TracedArrayBase& pushString(const String& value)
+    {
+        TracedValueBase::pushString(value);
+        return *this;
+    }
+
+private:
+    TracedArrayBase();
+    ~TracedArrayBase();
+};
+
 template <class OwnerType>
-class TracedArray : public TracedValueBase {
+class TracedArray : public TracedArrayBase {
     WTF_MAKE_NONCOPYABLE(TracedArray);
 public:
     TracedDictionary<TracedArray<OwnerType> >& beginDictionary()
     {
-        pushDictionary();
+        TracedArrayBase::beginDictionary();
         return *reinterpret_cast<TracedDictionary<TracedArray<OwnerType> >* >(this);
     }
-    TracedDictionary<TracedArray<OwnerType> >& beginArray()
+    TracedArray<TracedArray<OwnerType> >& beginArray()
     {
-        pushArray();
-        return *reinterpret_cast<TracedDictionary<TracedArray<OwnerType> >* >(this);
+        TracedArrayBase::beginArray();
+        return *reinterpret_cast<TracedArray<TracedArray<OwnerType> >* >(this);
     }
     OwnerType& endArray()
     {
         ASSERT(m_stack.size() == nestingLevel);
-        endCurrentArray();
+        TracedArrayBase::endArray();
         return *reinterpret_cast<OwnerType*>(this);
     }
 
     TracedArray<OwnerType>& pushInteger(int value)
     {
-        TracedValueBase::pushInteger(value);
+        TracedArrayBase::pushInteger(value);
         return *this;
     }
     TracedArray<OwnerType>& pushDouble(double value)
     {
-        TracedValueBase::pushDouble(value);
+        TracedArrayBase::pushDouble(value);
         return *this;
     }
     TracedArray<OwnerType>& pushBoolean(bool value)
     {
-        TracedValueBase::pushBoolean(value);
+        TracedArrayBase::pushBoolean(value);
         return *this;
     }
     TracedArray<OwnerType>& pushString(const String& value)
     {
-        TracedValueBase::pushString(value);
+        TracedArrayBase::pushString(value);
         return *this;
     }
 
     static const size_t nestingLevel = OwnerType::nestingLevel + 1;
 
 private:
     TracedArray();
     ~TracedArray();
 };
 
@@ skipping 26 matching lines @@
         return *this;
     }
     PassRefPtr<TraceEvent::ConvertableToTraceFormat> finish();
 
     static const size_t nestingLevel = 1;
 };
 
 } // namespace WebCore
 
 #endif // TracedValue_h