Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/platform/TraceEvent.h

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 19 matching lines @@
 #ifndef TraceEvent_h
 #define TraceEvent_h
 
 #include "platform/EventTracer.h"
 #include "platform/TraceEventCommon.h"
 
 #include "platform/TracedValue.h"
 #include "wtf/Allocator.h"
 #include "wtf/DynamicAnnotations.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/PassOwnPtr.h"
 #include "wtf/text/CString.h"
-#include <memory>
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation specific tracing API definitions.
 
 // By default, const char* argument values are assumed to have long-lived scope
 // and will not be copied. Use this macro to force a const char* to be copied.
 #define TRACE_STR_COPY(str) \
     blink::TraceEvent::TraceStringWithCopy(str)
 
 // By default, uint64 ID argument values are not mangled with the Process ID in
@@ skipping 57 matching lines @@
 // Add a trace event to the platform tracing system.
 // blink::TraceEvent::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT(
 //                    const char* name,
 //                    const char* scope,
 //                    unsigned long long id,
 //                    double timestamp,
 //                    int num_args,
 //                    const char** arg_names,
 //                    const unsigned char* arg_types,
 //                    const unsigned long long* arg_values,
-//                    std::unique_ptr<TracedValue> tracedValues[],
+//                    PassOwnPtr<TracedValue> tracedValues[],
 //                    unsigned char flags)
 #define TRACE_EVENT_API_ADD_TRACE_EVENT \
     blink::EventTracer::addTraceEvent
 
 // Set the duration field of a COMPLETE trace event.
 // void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
 //     blink::TraceEvent::TraceEventHandle handle)
 #define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
     blink::EventTracer::updateTraceEventDuration
 
@@ skipping 290 matching lines @@
     typeValue.m_string = arg.data();
     *type = TRACE_VALUE_TYPE_COPY_STRING;
     *value = typeValue.m_uint;
 }
 
 static inline void setTraceValue(TracedValue*, unsigned char* type, unsigned long long*)
 {
     *type = TRACE_VALUE_TYPE_CONVERTABLE;
 }
 
-template<typename T> static inline void setTraceValue(const std::unique_ptr<T>& ptr, unsigned char* type, unsigned long long* value)
+template<typename T> static inline void setTraceValue(const PassOwnPtr<T>& ptr, unsigned char* type, unsigned long long* value)
 {
     setTraceValue(ptr.get(), type, value);
 }
 
 template<typename T> struct TracedValueTraits {
     static const bool isTracedValue = false;
-    static std::unique_ptr<TracedValue> moveFromIfTracedValue(const T&)
+    static PassOwnPtr<TracedValue> moveFromIfTracedValue(const T&)
     {
         return nullptr;
     }
 };
 
-template<typename T> struct TracedValueTraits<std::unique_ptr<T>> {
+template<typename T> struct TracedValueTraits<PassOwnPtr<T>> {
     static const bool isTracedValue = std::is_convertible<T*, TracedValue*>::value;
-    static std::unique_ptr<TracedValue> moveFromIfTracedValue(std::unique_ptr<T>&& tracedValue)
+    static PassOwnPtr<TracedValue> moveFromIfTracedValue(PassOwnPtr<T>&& tracedValue)
     {
         return std::move(tracedValue);
     }
 };
 
 template<typename T> bool isTracedValue(const T&)
 {
     return TracedValueTraits<T>::isTracedValue;
 }
 
-template<typename T> std::unique_ptr<TracedValue> moveFromIfTracedValue(T&& value)
+template<typename T> PassOwnPtr<TracedValue> moveFromIfTracedValue(T&& value)
 {
     return TracedValueTraits<T>::moveFromIfTracedValue(std::forward<T>(value));
 }
 
 // These addTraceEvent template functions are defined here instead of in the
 // macro, because the arg values could be temporary string objects. In order to
 // store pointers to the internal c_str and pass through to the tracing API, the
 // arg values must live throughout these procedures.
 
 static inline TraceEventHandle addTraceEvent(
@@ skipping 215 matching lines @@
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
 } // namespace blink
 
 #endif