Use chromium trace_event implementation in blink

third_party/WebKit/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 "platform/TracedValue.h"
 
-#include "base/trace_event/trace_event_argument.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringUTF8Adaptor.h"
-#include <memory>
 
 namespace blink {
 
 std::unique_ptr<TracedValue> TracedValue::create()
 {
     return wrapUnique(new TracedValue());
 }
 
 TracedValue::TracedValue()
-    : m_tracedValue(new base::trace_event::TracedValue)
 {
 }
 
 TracedValue::~TracedValue()
 {
 }
 
 void TracedValue::setInteger(const char* name, int value)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->SetIntegerWithCopiedName(name, value);
+    m_tracedValue.SetIntegerWithCopiedName(name, value);
 }
 
 void TracedValue::setDouble(const char* name, double value)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->SetDoubleWithCopiedName(name, value);
+    m_tracedValue.SetDoubleWithCopiedName(name, value);
 }
 
 void TracedValue::setBoolean(const char* name, bool value)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->SetBooleanWithCopiedName(name, value);
+    m_tracedValue.SetBooleanWithCopiedName(name, value);
 }
 
 void TracedValue::setString(const char* name, const String& value)
 {
-    ASSERT(m_tracedValue.get());
     StringUTF8Adaptor adaptor(value);
-    m_tracedValue->SetStringWithCopiedName(name, adaptor.asStringPiece());
+    m_tracedValue.SetStringWithCopiedName(name, adaptor.asStringPiece());
 }
 
 void TracedValue::beginDictionary(const char* name)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->BeginDictionaryWithCopiedName(name);
+    m_tracedValue.BeginDictionaryWithCopiedName(name);
 }
 
 void TracedValue::beginArray(const char* name)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->BeginArrayWithCopiedName(name);
+    m_tracedValue.BeginArrayWithCopiedName(name);
 }
 
 void TracedValue::endDictionary()
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->EndDictionary();
+    m_tracedValue.EndDictionary();
 }
 
 void TracedValue::pushInteger(int value)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->AppendInteger(value);
+    m_tracedValue.AppendInteger(value);
 }
 
 void TracedValue::pushDouble(double value)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->AppendDouble(value);
+    m_tracedValue.AppendDouble(value);
 }
 
 void TracedValue::pushBoolean(bool value)
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->AppendBoolean(value);
+    m_tracedValue.AppendBoolean(value);
 }
 
 void TracedValue::pushString(const String& value)
 {
-    ASSERT(m_tracedValue.get());
     StringUTF8Adaptor adaptor(value);
-    m_tracedValue->AppendString(adaptor.asStringPiece());
+    m_tracedValue.AppendString(adaptor.asStringPiece());
 }
 
 void TracedValue::beginArray()
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->BeginArray();
+    m_tracedValue.BeginArray();
 }
 
 void TracedValue::beginDictionary()
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->BeginDictionary();
+    m_tracedValue.BeginDictionary();
 }
 
 void TracedValue::endArray()
 {
-    ASSERT(m_tracedValue.get());
-    m_tracedValue->EndArray();
+    m_tracedValue.EndArray();
 }
 
 String TracedValue::toString() const
 {
-    ASSERT(m_tracedValue.get());
-    std::string out;
-    m_tracedValue->AppendAsTraceFormat(&out);
-    return String::fromUTF8(out.c_str());
+    return String(m_tracedValue.ToString().c_str());
+}
+
+void TracedValue::AppendAsTraceFormat(std::string* out) const
+{
+    m_tracedValue.AppendAsTraceFormat(out);
+}
+
+void TracedValue::EstimateTraceMemoryOverhead(base::trace_event::TraceEventMemoryOverhead* overhead)
+{
+    m_tracedValue.EstimateTraceMemoryOverhead(overhead);
 }
 
 } // namespace blink