NOCOMMIT: Blink tracing now uses base

third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp

Index: third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp
diff --git a/third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp b/third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp
index 5f50ba4b2ef521deb3456467a8966356f6faec14..43e8d9fc19b19a3f2dfaa2a04b658405642cf583 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp
@@ -48,7 +48,7 @@ void setCallStack(TracedValue* value)
     static const unsigned char* traceCategoryEnabled = 0;
     WTF_ANNOTATE_BENIGN_RACE(&traceCategoryEnabled, "trace_event category");
     if (!traceCategoryEnabled)
-        traceCategoryEnabled = TRACE_EVENT_API_GET_CATEGORY_ENABLED(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"));
+        traceCategoryEnabled = TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"));
     if (!*traceCategoryEnabled)
         return;
     RefPtrWillBeRawPtr<ScriptCallStack> scriptCallStack = currentScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture);
@@ -160,16 +160,16 @@ const char* pseudoTypeToString(CSSSelector::PseudoType pseudoType)
 }
 
 namespace InspectorScheduleStyleInvalidationTrackingEvent {
-PassRefPtr<TracedValue> fillCommonPart(Element& element, const InvalidationSet& invalidationSet, const char* invalidatedSelector)
+scoped_refptr<TracedValue> fillCommonPart(Element& element, const InvalidationSet& invalidationSet, const char* invalidatedSelector)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(element.document().frame()));
     setNodeInfo(value.get(), &element, "nodeId", "nodeName");
     value->setString("invalidationSet", descendantInvalidationSetToIdString(invalidationSet));
     value->setString("invalidatedSelectorId", invalidatedSelector);
     if (RefPtrWillBeRawPtr<ScriptCallStack> stackTrace = currentScriptCallStack(maxInvalidationTrackingCallstackSize))
         stackTrace->toTracedValue(value.get(), "stackTrace");
-    return value.release();
+    return value;
 }
 } // namespace InspectorScheduleStyleInvalidationTrackingEvent
 
@@ -178,32 +178,32 @@ const char InspectorScheduleStyleInvalidationTrackingEvent::Class[] = "class";
 const char InspectorScheduleStyleInvalidationTrackingEvent::Id[] = "id";
 const char InspectorScheduleStyleInvalidationTrackingEvent::Pseudo[] = "pseudo";
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::idChange(Element& element, const InvalidationSet& invalidationSet, const AtomicString& id)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::idChange(Element& element, const InvalidationSet& invalidationSet, const AtomicString& id)
 {
-    RefPtr<TracedValue> value = fillCommonPart(element, invalidationSet, Id);
+    scoped_refptr<TracedValue> value = fillCommonPart(element, invalidationSet, Id);
     value->setString("changedId", id);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::classChange(Element& element, const InvalidationSet& invalidationSet, const AtomicString& className)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::classChange(Element& element, const InvalidationSet& invalidationSet, const AtomicString& className)
 {
-    RefPtr<TracedValue> value = fillCommonPart(element, invalidationSet, Class);
+    scoped_refptr<TracedValue> value = fillCommonPart(element, invalidationSet, Class);
     value->setString("changedClass", className);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::attributeChange(Element& element, const InvalidationSet& invalidationSet, const QualifiedName& attributeName)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::attributeChange(Element& element, const InvalidationSet& invalidationSet, const QualifiedName& attributeName)
 {
-    RefPtr<TracedValue> value = fillCommonPart(element, invalidationSet, Attribute);
+    scoped_refptr<TracedValue> value = fillCommonPart(element, invalidationSet, Attribute);
     value->setString("changedAttribute", attributeName.toString());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::pseudoChange(Element& element, const InvalidationSet& invalidationSet, CSSSelector::PseudoType pseudoType)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorScheduleStyleInvalidationTrackingEvent::pseudoChange(Element& element, const InvalidationSet& invalidationSet, CSSSelector::PseudoType pseudoType)
 {
-    RefPtr<TracedValue> value = fillCommonPart(element, invalidationSet, Attribute);
+    scoped_refptr<TracedValue> value = fillCommonPart(element, invalidationSet, Attribute);
     value->setString("changedPseudo", pseudoTypeToString(pseudoType));
-    return value.release();
+    return value;
 }
 
 String descendantInvalidationSetToIdString(const InvalidationSet& set)
@@ -220,56 +220,56 @@ const char InspectorStyleInvalidatorInvalidateEvent::InvalidationSetMatchedTagNa
 const char InspectorStyleInvalidatorInvalidateEvent::PreventStyleSharingForParent[] = "Prevent style sharing for parent";
 
 namespace InspectorStyleInvalidatorInvalidateEvent {
-PassRefPtr<TracedValue> fillCommonPart(Element& element, const char* reason)
+scoped_refptr<TracedValue> fillCommonPart(Element& element, const char* reason)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(element.document().frame()));
     setNodeInfo(value.get(), &element, "nodeId", "nodeName");
     value->setString("reason", reason);
-    return value.release();
+    return value;
 }
 } // namespace InspectorStyleInvalidatorInvalidateEvent
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorStyleInvalidatorInvalidateEvent::data(Element& element, const char* reason)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorStyleInvalidatorInvalidateEvent::data(Element& element, const char* reason)
 {
     return fillCommonPart(element, reason);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorStyleInvalidatorInvalidateEvent::selectorPart(Element& element, const char* reason, const InvalidationSet& invalidationSet, const String& selectorPart)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorStyleInvalidatorInvalidateEvent::selectorPart(Element& element, const char* reason, const InvalidationSet& invalidationSet, const String& selectorPart)
 {
-    RefPtr<TracedValue> value = fillCommonPart(element, reason);
+    scoped_refptr<TracedValue> value = fillCommonPart(element, reason);
     value->beginArray("invalidationList");
     invalidationSet.toTracedValue(value.get());
     value->endArray();
     value->setString("selectorPart", selectorPart);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorStyleInvalidatorInvalidateEvent::invalidationList(Element& element, const WillBeHeapVector<RefPtrWillBeMember<InvalidationSet>>& invalidationList)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorStyleInvalidatorInvalidateEvent::invalidationList(Element& element, const WillBeHeapVector<RefPtrWillBeMember<InvalidationSet>>& invalidationList)
 {
-    RefPtr<TracedValue> value = fillCommonPart(element, ElementHasPendingInvalidationList);
+    scoped_refptr<TracedValue> value = fillCommonPart(element, ElementHasPendingInvalidationList);
     value->beginArray("invalidationList");
     for (const auto& invalidationSet : invalidationList)
         invalidationSet->toTracedValue(value.get());
     value->endArray();
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorStyleRecalcInvalidationTrackingEvent::data(Node* node, const StyleChangeReasonForTracing& reason)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorStyleRecalcInvalidationTrackingEvent::data(Node* node, const StyleChangeReasonForTracing& reason)
 {
     ASSERT(node);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(node->document().frame()));
     setNodeInfo(value.get(), node, "nodeId", "nodeName");
     value->setString("reason", reason.reasonString());
     value->setString("extraData", reason.extraData());
     if (RefPtrWillBeRawPtr<ScriptCallStack> stackTrace = currentScriptCallStack(maxInvalidationTrackingCallstackSize))
         stackTrace->toTracedValue(value.get(), "stackTrace");
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorLayoutEvent::beginData(FrameView* frameView)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorLayoutEvent::beginData(FrameView* frameView)
 {
     bool isPartial;
     unsigned needsLayoutObjects;
@@ -277,13 +277,13 @@ PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorLayoutEvent::beginData
     LocalFrame& frame = frameView->frame();
     frame.view()->countObjectsNeedingLayout(needsLayoutObjects, totalObjects, isPartial);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setInteger("dirtyObjects", needsLayoutObjects);
     value->setInteger("totalObjects", totalObjects);
     value->setBoolean("partialLayout", isPartial);
     value->setString("frame", toHexString(&frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
 static void createQuad(TracedValue* value, const char* name, const FloatQuad& quad)
@@ -311,19 +311,19 @@ static void setGeneratingNodeInfo(TracedValue* value, const LayoutObject* layout
     setNodeInfo(value, node, idFieldName, nameFieldName);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorLayoutEvent::endData(LayoutObject* rootForThisLayout)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorLayoutEvent::endData(LayoutObject* rootForThisLayout)
 {
     Vector<FloatQuad> quads;
     rootForThisLayout->absoluteQuads(quads);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     if (quads.size() >= 1) {
         createQuad(value.get(), "root", quads[0]);
         setGeneratingNodeInfo(value.get(), rootForThisLayout, "rootNode");
     } else {
         ASSERT_NOT_REACHED();
     }
-    return value.release();
+    return value;
 }
 
 namespace LayoutInvalidationReason {
@@ -361,87 +361,87 @@ const char SvgChanged[] = "SVG changed";
 const char ScrollbarChanged[] = "Scrollbar changed";
 } // namespace LayoutInvalidationReason
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorLayoutInvalidationTrackingEvent::data(const LayoutObject* layoutObject, LayoutInvalidationReasonForTracing reason)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorLayoutInvalidationTrackingEvent::data(const LayoutObject* layoutObject, LayoutInvalidationReasonForTracing reason)
 {
     ASSERT(layoutObject);
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(layoutObject->frame()));
     setGeneratingNodeInfo(value.get(), layoutObject, "nodeId", "nodeName");
     value->setString("reason", reason);
     if (RefPtrWillBeRawPtr<ScriptCallStack> stackTrace = currentScriptCallStack(maxInvalidationTrackingCallstackSize))
         stackTrace->toTracedValue(value.get(), "stackTrace");
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorPaintInvalidationTrackingEvent::data(const LayoutObject* layoutObject, const LayoutObject& paintContainer)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorPaintInvalidationTrackingEvent::data(const LayoutObject* layoutObject, const LayoutObject& paintContainer)
 {
     ASSERT(layoutObject);
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(layoutObject->frame()));
     setGeneratingNodeInfo(value.get(), &paintContainer, "paintId");
     setGeneratingNodeInfo(value.get(), layoutObject, "nodeId", "nodeName");
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorScrollInvalidationTrackingEvent::data(const LayoutObject& layoutObject)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorScrollInvalidationTrackingEvent::data(const LayoutObject& layoutObject)
 {
     static const char ScrollInvalidationReason[] = "Scroll with viewport-constrained element";
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(layoutObject.frame()));
     value->setString("reason", ScrollInvalidationReason);
     setGeneratingNodeInfo(value.get(), &layoutObject, "nodeId", "nodeName");
     if (RefPtrWillBeRawPtr<ScriptCallStack> stackTrace = currentScriptCallStack(maxInvalidationTrackingCallstackSize))
         stackTrace->toTracedValue(value.get(), "stackTrace");
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorSendRequestEvent::data(unsigned long identifier, LocalFrame* frame, const ResourceRequest& request)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorSendRequestEvent::data(unsigned long identifier, LocalFrame* frame, const ResourceRequest& request)
 {
     String requestId = IdentifiersFactory::requestId(identifier);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("requestId", requestId);
     value->setString("frame", toHexString(frame));
     value->setString("url", request.url().string());
     value->setString("requestMethod", request.httpMethod());
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorReceiveResponseEvent::data(unsigned long identifier, LocalFrame* frame, const ResourceResponse& response)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorReceiveResponseEvent::data(unsigned long identifier, LocalFrame* frame, const ResourceResponse& response)
 {
     String requestId = IdentifiersFactory::requestId(identifier);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("requestId", requestId);
     value->setString("frame", toHexString(frame));
     value->setInteger("statusCode", response.httpStatusCode());
     value->setString("mimeType", response.mimeType().string().isolatedCopy());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorReceiveDataEvent::data(unsigned long identifier, LocalFrame* frame, int encodedDataLength)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorReceiveDataEvent::data(unsigned long identifier, LocalFrame* frame, int encodedDataLength)
 {
     String requestId = IdentifiersFactory::requestId(identifier);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("requestId", requestId);
     value->setString("frame", toHexString(frame));
     value->setInteger("encodedDataLength", encodedDataLength);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorResourceFinishEvent::data(unsigned long identifier, double finishTime, bool didFail)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorResourceFinishEvent::data(unsigned long identifier, double finishTime, bool didFail)
 {
     String requestId = IdentifiersFactory::requestId(identifier);
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("requestId", requestId);
     value->setBoolean("didFail", didFail);
     if (finishTime)
         value->setDouble("networkTime", finishTime);
-    return value.release();
+    return value;
 }
 
 static LocalFrame* frameForExecutionContext(ExecutionContext* context)
@@ -452,119 +452,119 @@ static LocalFrame* frameForExecutionContext(ExecutionContext* context)
     return frame;
 }
 
-static PassRefPtr<TracedValue> genericTimerData(ExecutionContext* context, int timerId)
+static scoped_refptr<TracedValue> genericTimerData(ExecutionContext* context, int timerId)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setInteger("timerId", timerId);
     if (LocalFrame* frame = frameForExecutionContext(context))
         value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorTimerInstallEvent::data(ExecutionContext* context, int timerId, int timeout, bool singleShot)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorTimerInstallEvent::data(ExecutionContext* context, int timerId, int timeout, bool singleShot)
 {
-    RefPtr<TracedValue> value = genericTimerData(context, timerId);
+    scoped_refptr<TracedValue> value = genericTimerData(context, timerId);
     value->setInteger("timeout", timeout);
     value->setBoolean("singleShot", singleShot);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorTimerRemoveEvent::data(ExecutionContext* context, int timerId)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorTimerRemoveEvent::data(ExecutionContext* context, int timerId)
 {
     return genericTimerData(context, timerId);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorTimerFireEvent::data(ExecutionContext* context, int timerId)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorTimerFireEvent::data(ExecutionContext* context, int timerId)
 {
     return genericTimerData(context, timerId);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorAnimationFrameEvent::data(ExecutionContext* context, int callbackId)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorAnimationFrameEvent::data(ExecutionContext* context, int callbackId)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setInteger("id", callbackId);
     if (context->isDocument())
         value->setString("frame", toHexString(toDocument(context)->frame()));
     else if (context->isWorkerGlobalScope())
         value->setString("worker", toHexString(toWorkerGlobalScope(context)));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TracedValue> genericIdleCallbackEvent(ExecutionContext* context, int id)
+scoped_refptr<TracedValue> genericIdleCallbackEvent(ExecutionContext* context, int id)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setInteger("id", id);
     if (LocalFrame* frame = frameForExecutionContext(context))
         value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorIdleCallbackRequestEvent::data(ExecutionContext* context, int id, double timeout)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorIdleCallbackRequestEvent::data(ExecutionContext* context, int id, double timeout)
 {
-    RefPtr<TracedValue> value = genericIdleCallbackEvent(context, id);
+    scoped_refptr<TracedValue> value = genericIdleCallbackEvent(context, id);
     value->setInteger("timeout", timeout);
     return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorIdleCallbackCancelEvent::data(ExecutionContext* context, int id)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorIdleCallbackCancelEvent::data(ExecutionContext* context, int id)
 {
     return genericIdleCallbackEvent(context, id);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorIdleCallbackFireEvent::data(ExecutionContext* context, int id, double allottedMilliseconds, bool timedOut)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorIdleCallbackFireEvent::data(ExecutionContext* context, int id, double allottedMilliseconds, bool timedOut)
 {
-    RefPtr<TracedValue> value = genericIdleCallbackEvent(context, id);
+    scoped_refptr<TracedValue> value = genericIdleCallbackEvent(context, id);
     value->setDouble("allottedMilliseconds", allottedMilliseconds);
     value->setBoolean("timedOut", timedOut);
     return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorParseHtmlEvent::beginData(Document* document, unsigned startLine)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorParseHtmlEvent::beginData(Document* document, unsigned startLine)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setInteger("startLine", startLine);
     value->setString("frame", toHexString(document->frame()));
     value->setString("url", document->url().string());
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorParseHtmlEvent::endData(unsigned endLine)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorParseHtmlEvent::endData(unsigned endLine)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setInteger("endLine", endLine);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorParseAuthorStyleSheetEvent::data(const CSSStyleSheetResource* cachedStyleSheet)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorParseAuthorStyleSheetEvent::data(const CSSStyleSheetResource* cachedStyleSheet)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("styleSheetUrl", cachedStyleSheet->url().string());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorXhrReadyStateChangeEvent::data(ExecutionContext* context, XMLHttpRequest* request)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorXhrReadyStateChangeEvent::data(ExecutionContext* context, XMLHttpRequest* request)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("url", request->url().string());
     value->setInteger("readyState", request->readyState());
     if (LocalFrame* frame = frameForExecutionContext(context))
         value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorXhrLoadEvent::data(ExecutionContext* context, XMLHttpRequest* request)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorXhrLoadEvent::data(ExecutionContext* context, XMLHttpRequest* request)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("url", request->url().string());
     if (LocalFrame* frame = frameForExecutionContext(context))
         value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
 static void localToPageQuad(const LayoutObject& layoutObject, const LayoutRect& rect, FloatQuad* quad)
@@ -584,20 +584,20 @@ const char InspectorLayerInvalidationTrackingEvent::RemovedFromSquashingLayer[]
 const char InspectorLayerInvalidationTrackingEvent::ReflectionLayerChanged[] = "Reflection layer change";
 const char InspectorLayerInvalidationTrackingEvent::NewCompositedLayer[] = "Assigned a new composited layer";
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorLayerInvalidationTrackingEvent::data(const DeprecatedPaintLayer* layer, const char* reason)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorLayerInvalidationTrackingEvent::data(const DeprecatedPaintLayer* layer, const char* reason)
 {
     const LayoutObject* paintInvalidationContainer = layer->layoutObject()->containerForPaintInvalidation();
 
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(paintInvalidationContainer->frame()));
     setGeneratingNodeInfo(value.get(), paintInvalidationContainer, "paintId");
     value->setString("reason", reason);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorPaintEvent::data(LayoutObject* layoutObject, const LayoutRect& clipRect, const GraphicsLayer* graphicsLayer)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorPaintEvent::data(LayoutObject* layoutObject, const LayoutRect& clipRect, const GraphicsLayer* graphicsLayer)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(layoutObject->frame()));
     FloatQuad quad;
     localToPageQuad(*layoutObject, clipRect, &quad);
@@ -606,91 +606,91 @@ PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorPaintEvent::data(Layou
     int graphicsLayerId = graphicsLayer ? graphicsLayer->platformLayer()->id() : 0;
     value->setInteger("layerId", graphicsLayerId);
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> frameEventData(LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> frameEventData(LocalFrame* frame)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(frame));
     bool isMainFrame = frame && frame->isMainFrame();
     value->setBoolean("isMainFrame", isMainFrame);
     value->setString("page", toHexString(frame));
-    return value.release();
+    return value;
 }
 
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorCommitLoadEvent::data(LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorCommitLoadEvent::data(LocalFrame* frame)
 {
     return frameEventData(frame);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorMarkLoadEvent::data(LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorMarkLoadEvent::data(LocalFrame* frame)
 {
     return frameEventData(frame);
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorScrollLayerEvent::data(LayoutObject* layoutObject)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorScrollLayerEvent::data(LayoutObject* layoutObject)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(layoutObject->frame()));
     setGeneratingNodeInfo(value.get(), layoutObject, "nodeId");
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorUpdateLayerTreeEvent::data(LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorUpdateLayerTreeEvent::data(LocalFrame* frame)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(frame));
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorEvaluateScriptEvent::data(LocalFrame* frame, const String& url, int lineNumber)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorEvaluateScriptEvent::data(LocalFrame* frame, const String& url, int lineNumber)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(frame));
     value->setString("url", url);
     value->setInteger("lineNumber", lineNumber);
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorFunctionCallEvent::data(ExecutionContext* context, int scriptId, const String& scriptName, int scriptLine)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorFunctionCallEvent::data(ExecutionContext* context, int scriptId, const String& scriptName, int scriptLine)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("scriptId", String::number(scriptId));
     value->setString("scriptName", scriptName);
     value->setInteger("scriptLine", scriptLine);
     if (LocalFrame* frame = frameForExecutionContext(context))
         value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorPaintImageEvent::data(const LayoutImage& layoutImage)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorPaintImageEvent::data(const LayoutImage& layoutImage)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     setGeneratingNodeInfo(value.get(), &layoutImage, "nodeId");
     if (const ImageResource* resource = layoutImage.cachedImage())
         value->setString("url", resource->url().string());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorPaintImageEvent::data(const LayoutObject& owningLayoutObject, const StyleImage& styleImage)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorPaintImageEvent::data(const LayoutObject& owningLayoutObject, const StyleImage& styleImage)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     setGeneratingNodeInfo(value.get(), &owningLayoutObject, "nodeId");
     if (const ImageResource* resource = styleImage.cachedImage())
         value->setString("url", resource->url().string());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorPaintImageEvent::data(const LayoutObject* owningLayoutObject, const ImageResource& imageResource)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorPaintImageEvent::data(const LayoutObject* owningLayoutObject, const ImageResource& imageResource)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     setGeneratingNodeInfo(value.get(), owningLayoutObject, "nodeId");
     value->setString("url", imageResource.url().string());
-    return value.release();
+    return value;
 }
 
 static size_t usedHeapSize()
@@ -700,79 +700,79 @@ static size_t usedHeapSize()
     return heapStatistics.used_heap_size();
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorUpdateCountersEvent::data()
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorUpdateCountersEvent::data()
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     if (isMainThread()) {
         value->setInteger("documents", InstanceCounters::counterValue(InstanceCounters::DocumentCounter));
         value->setInteger("nodes", InstanceCounters::counterValue(InstanceCounters::NodeCounter));
         value->setInteger("jsEventListeners", InstanceCounters::counterValue(InstanceCounters::JSEventListenerCounter));
     }
     value->setDouble("jsHeapSizeUsed", static_cast<double>(usedHeapSize()));
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorInvalidateLayoutEvent::data(LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorInvalidateLayoutEvent::data(LocalFrame* frame)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorRecalculateStylesEvent::data(LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorRecalculateStylesEvent::data(LocalFrame* frame)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("frame", toHexString(frame));
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorEventDispatchEvent::data(const Event& event)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorEventDispatchEvent::data(const Event& event)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("type", event.type());
     setCallStack(value.get());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorTimeStampEvent::data(ExecutionContext* context, const String& message)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorTimeStampEvent::data(ExecutionContext* context, const String& message)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("message", message);
     if (LocalFrame* frame = frameForExecutionContext(context))
         value->setString("frame", toHexString(frame));
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorTracingSessionIdForWorkerEvent::data(const String& sessionId, const String& workerId, WorkerThread* workerThread)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorTracingSessionIdForWorkerEvent::data(const String& sessionId, const String& workerId, WorkerThread* workerThread)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("sessionId", sessionId);
     value->setString("workerId", workerId);
     value->setDouble("workerThreadId", workerThread->platformThreadId());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorTracingStartedInFrame::data(const String& sessionId, LocalFrame* frame)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorTracingStartedInFrame::data(const String& sessionId, LocalFrame* frame)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("sessionId", sessionId);
     value->setString("page", toHexString(frame));
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorSetLayerTreeId::data(const String& sessionId, int layerTreeId)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorSetLayerTreeId::data(const String& sessionId, int layerTreeId)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("sessionId", sessionId);
     value->setInteger("layerTreeId", layerTreeId);
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorAnimationEvent::data(const Animation& player)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorAnimationEvent::data(const Animation& player)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("id", String::number(player.sequenceNumber()));
     value->setString("state", player.playState());
     if (const AnimationEffect* effect = player.effect()) {
@@ -782,19 +782,19 @@ PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorAnimationEvent::data(c
                 setNodeInfo(value.get(), target, "nodeId", "nodeName");
         }
     }
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorAnimationStateEvent::data(const Animation& player)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorAnimationStateEvent::data(const Animation& player)
 {
-    RefPtr<TracedValue> value = TracedValue::create();
+    scoped_refptr<TracedValue> value = TracedValue::create();
     value->setString("state", player.playState());
-    return value.release();
+    return value;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> InspectorHitTestEvent::endData(const HitTestRequest& request, const HitTestLocation& location, const HitTestResult& result)
+scoped_refptr<base::trace_event::ConvertableToTraceFormat> InspectorHitTestEvent::endData(const HitTestRequest& request, const HitTestLocation& location, const HitTestResult& result)
 {
-    RefPtr<TracedValue> value(TracedValue::create());
+    scoped_refptr<TracedValue> value(TracedValue::create());
     value->setInteger("x", location.roundedPoint().x());
     value->setInteger("y", location.roundedPoint().y());
     if (location.isRectBasedTest())