Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/platform/geometry/FloatPolygon.h

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. 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.
@@ skipping 17 matching lines @@
  */
 
 #ifndef FloatPolygon_h
 #define FloatPolygon_h
 
 #include "platform/PODIntervalTree.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/GraphicsTypes.h"
 #include "wtf/Allocator.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
 #include "wtf/Vector.h"
-#include <memory>
 
 namespace blink {
 
 class FloatPolygonEdge;
 
 // This class is used by PODIntervalTree for debugging.
 #ifndef NDEBUG
 template <class> struct ValueToString;
 #endif
 
 class PLATFORM_EXPORT FloatPolygon {
     USING_FAST_MALLOC(FloatPolygon);
     WTF_MAKE_NONCOPYABLE(FloatPolygon);
 public:
-    FloatPolygon(std::unique_ptr<Vector<FloatPoint>> vertices, WindRule fillRule);
+    FloatPolygon(PassOwnPtr<Vector<FloatPoint>> vertices, WindRule fillRule);
 
     const FloatPoint& vertexAt(unsigned index) const { return (*m_vertices)[index]; }
     unsigned numberOfVertices() const { return m_vertices->size(); }
 
     WindRule fillRule() const { return m_fillRule; }
 
     const FloatPolygonEdge& edgeAt(unsigned index) const { return m_edges[index]; }
     unsigned numberOfEdges() const { return m_edges.size(); }
 
     FloatRect boundingBox() const { return m_boundingBox; }
     bool overlappingEdges(float minY, float maxY, Vector<const FloatPolygonEdge*>& result) const;
     bool contains(const FloatPoint&) const;
     bool isEmpty() const { return m_empty; }
 
 private:
     typedef PODInterval<float, FloatPolygonEdge*> EdgeInterval;
     typedef PODIntervalTree<float, FloatPolygonEdge*> EdgeIntervalTree;
 
     bool containsNonZero(const FloatPoint&) const;
     bool containsEvenOdd(const FloatPoint&) const;
 
-    std::unique_ptr<Vector<FloatPoint>> m_vertices;
+    OwnPtr<Vector<FloatPoint>> m_vertices;
     WindRule m_fillRule;
     FloatRect m_boundingBox;
     bool m_empty;
     Vector<FloatPolygonEdge> m_edges;
     EdgeIntervalTree m_edgeTree; // Each EdgeIntervalTree node stores minY, maxY, and a ("UserData") pointer to a FloatPolygonEdge.
 
 };
 
 class PLATFORM_EXPORT VertexPair {
 public:
@@ skipping 61 matching lines @@
 
 template<> struct ValueToString<FloatPolygonEdge*> {
     STATIC_ONLY(ValueToString);
     static String toString(const FloatPolygonEdge* edge) { return String::format("%p (%f,%f %f,%f)", edge, edge->vertex1().x(), edge->vertex1().y(), edge->vertex2().x(), edge->vertex2().y()); }
 };
 #endif
 
 } // namespace blink
 
 #endif // FloatPolygon_h