Changeset 166489 in webkit

Timestamp:

Mar 31, 2014 3:12:49 AM (10 years ago)

Author:

zandobersek@gmail.com

Message:

Move Source/WebCore/rendering/ code to std::unique_ptr
​https://bugs.webkit.org/show_bug.cgi?id=129664

Reviewed by Anders Carlsson.

Replace uses of OwnPtr and PassOwnPtr in code under Source/WebCore/rendering/ with std::unique_ptr.

• platform/graphics/FloatPolygon.cpp:

(WebCore::FloatPolygon::FloatPolygon):

• platform/graphics/FloatPolygon.h:
• rendering/ClipPathOperation.h:
• rendering/FlowThreadController.cpp:

(WebCore::FlowThreadController::ensureRenderFlowThreadWithName):

• rendering/FlowThreadController.h:
• rendering/HitTestLocation.h:
• rendering/HitTestResult.cpp:

(WebCore::HitTestResult::HitTestResult):
(WebCore::HitTestResult::operator=):
(WebCore::HitTestResult::rectBasedTestResult):
(WebCore::HitTestResult::mutableRectBasedTestResult):

• rendering/HitTestResult.h:
• rendering/HitTestingTransformState.cpp:
• rendering/ImageQualityController.h:
• rendering/RenderBlock.cpp:

(WebCore::removeBlockFromDescendantAndContainerMaps):
(WebCore::RenderBlock::finishDelayUpdateScrollInfo):
(WebCore::RenderBlock::addContinuationWithOutline):
(WebCore::RenderBlock::paintContinuationOutlines):
(WebCore::RenderBlock::insertIntoTrackedRendererMaps):
(WebCore::RenderBlock::removeFromTrackedRendererMaps):
(WebCore::RenderBlock::setComputedColumnCountAndWidth):

• rendering/RenderBlock.h:
• rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::createFloatingObjects):

• rendering/RenderBlockFlow.h:
• rendering/RenderBoxRegionInfo.h:
• rendering/RenderButton.cpp:

(WebCore::RenderButton::styleDidChange):

• rendering/RenderButton.h:
• rendering/RenderCounter.cpp:

(WebCore::makeCounterNode):

• rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::updateAllLayerToRegionMappings):
(WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock):

• rendering/RenderFlowThread.h:
• rendering/RenderGeometryMap.cpp:

(WebCore::RenderGeometryMap::push):
(WebCore::RenderGeometryMap::pushView):

• rendering/RenderGeometryMap.h:
• rendering/RenderGrid.cpp:

(WebCore::RenderGrid::GridIterator::nextEmptyGridArea):
(WebCore::RenderGrid::placeItemsOnGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::resolveGridPositionsFromStyle):
(WebCore::RenderGrid::resolveGridPositionAgainstOppositePosition):
(WebCore::RenderGrid::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::RenderGrid::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
(WebCore::RenderGrid::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):

• rendering/RenderGrid.h:
• rendering/RenderImageResource.h:
• rendering/RenderLayer.cpp:

(WebCore::RenderLayer::updateDescendantsAreContiguousInStackingOrder):
(WebCore::RenderLayer::updateTransform):
(WebCore::RenderLayer::setupFilters):
(WebCore::RenderLayer::paintLayerContents):
(WebCore::RenderLayer::paintChildLayerIntoColumns):
(WebCore::RenderLayer::hitTestChildLayerColumns):
(WebCore::RenderLayer::updateClipRects):
(WebCore::RenderLayer::calculateClipRects):

• rendering/RenderLayer.h:

(WebCore::RenderLayer::clearZOrderLists):

• rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::notifyFlushBeforeDisplayRefresh):
(WebCore::RenderLayerCompositor::registerAllViewportConstrainedLayers):

• rendering/RenderLayerCompositor.h:
• rendering/RenderLayerFilterInfo.cpp:

(WebCore::RenderLayer::FilterInfo::map):
(WebCore::RenderLayer::FilterInfo::get):

• rendering/RenderLayerFilterInfo.h:
• rendering/RenderRegion.cpp:

(WebCore::RenderRegion::setRenderBoxRegionInfo):
(WebCore::RenderRegion::takeRenderBoxRegionInfo):

• rendering/RenderRegion.h:
• rendering/RenderTable.cpp:

(WebCore::RenderTable::styleDidChange):

• rendering/RenderTable.h:
• rendering/RenderView.cpp:

(WebCore::RenderView::selectionBounds):
(WebCore::RenderView::setSelection):
(WebCore::RenderView::compositor):
(WebCore::RenderView::flowThreadController):
(WebCore::RenderView::imageQualityController):

• rendering/RenderView.h:
• rendering/RootInlineBox.h:

(WebCore::RootInlineBox::appendFloat):

• rendering/TextAutosizer.h:
• rendering/shapes/PolygonShape.cpp:

(WebCore::computeShapePaddingBounds):
(WebCore::computeShapeMarginBounds):

• rendering/shapes/PolygonShape.h:

(WebCore::PolygonShape::PolygonShape):

• rendering/shapes/RasterShape.cpp:

(WebCore::RasterShapeIntervals::computeShapeMarginIntervals):

• rendering/shapes/RasterShape.h:

(WebCore::RasterShape::RasterShape):

• rendering/shapes/Shape.cpp:

(WebCore::createInsetShape):
(WebCore::createRectangleShape):
(WebCore::createCircleShape):
(WebCore::createEllipseShape):
(WebCore::createPolygonShape):
(WebCore::Shape::createShape):
(WebCore::Shape::createRasterShape):
(WebCore::Shape::createLayoutBoxShape):

• rendering/shapes/Shape.h:
• rendering/shapes/ShapeInfo.h:

(WebCore::ShapeInfo::markShapeAsDirty):
(WebCore::ShapeInfo::isShapeDirty):

• rendering/shapes/ShapeInsideInfo.h:
• rendering/style/ContentData.h:
• rendering/style/CounterDirectives.cpp:

(WebCore::clone):

• rendering/style/CounterDirectives.h:
• rendering/style/GridCoordinate.h:
• rendering/style/RenderStyle.cpp:

(WebCore::RenderStyle::addCachedPseudoStyle):
(WebCore::RenderStyle::accessCounterDirectives):
(WebCore::RenderStyle::accessAnimations):
(WebCore::RenderStyle::accessTransitions):

• rendering/style/RenderStyle.h:
• rendering/style/StyleRareNonInheritedData.cpp:

(WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):

• rendering/style/StyleRareNonInheritedData.h:
• rendering/svg/RenderSVGResourceGradient.cpp:

(WebCore::RenderSVGResourceGradient::applyResource):

• rendering/svg/RenderSVGResourceGradient.h:
• rendering/svg/RenderSVGResourcePattern.cpp:

(WebCore::RenderSVGResourcePattern::buildPattern):

• rendering/svg/RenderSVGResourcePattern.h:
• rendering/svg/RenderSVGShape.cpp:

(WebCore::RenderSVGShape::updateShapeFromElement):

• rendering/svg/RenderSVGShape.h:
• rendering/svg/SVGResources.cpp:

(WebCore::SVGResources::setClipper):
(WebCore::SVGResources::setFilter):
(WebCore::SVGResources::setMarkerStart):
(WebCore::SVGResources::setMarkerMid):
(WebCore::SVGResources::setMarkerEnd):
(WebCore::SVGResources::setMasker):
(WebCore::SVGResources::setFill):
(WebCore::SVGResources::setStroke):

• rendering/svg/SVGResources.h:
• rendering/svg/SVGResourcesCache.cpp:

(WebCore::SVGResourcesCache::addResourcesFromRenderer):
(WebCore::SVGResourcesCache::removeResourcesFromRenderer):

• rendering/svg/SVGResourcesCache.h:
• rendering/svg/SVGTextMetricsBuilder.cpp:

(WebCore::SVGTextMetricsBuilder::initializeMeasurementWithTextRenderer):

• rendering/svg/SVGTextMetricsBuilder.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/FloatPolygon.cpp (modified) (1 diff)
• platform/graphics/FloatPolygon.h (modified) (3 diffs)
• rendering/ClipPathOperation.h (modified) (1 diff)
• rendering/FlowThreadController.cpp (modified) (2 diffs)
• rendering/FlowThreadController.h (modified) (4 diffs)
• rendering/HitTestLocation.h (modified) (1 diff)
• rendering/HitTestResult.cpp (modified) (4 diffs)
• rendering/HitTestResult.h (modified) (2 diffs)
• rendering/HitTestingTransformState.cpp (modified) (1 diff)
• rendering/ImageQualityController.h (modified) (3 diffs)
• rendering/RenderBlock.cpp (modified) (10 diffs)
• rendering/RenderBlock.h (modified) (2 diffs)
• rendering/RenderBlockFlow.cpp (modified) (1 diff)
• rendering/RenderBlockFlow.h (modified) (2 diffs)
• rendering/RenderBoxRegionInfo.h (modified) (1 diff)
• rendering/RenderButton.cpp (modified) (1 diff)
• rendering/RenderButton.h (modified) (2 diffs)
• rendering/RenderCounter.cpp (modified) (2 diffs)
• rendering/RenderFlowThread.cpp (modified) (2 diffs)
• rendering/RenderFlowThread.h (modified) (1 diff)
• rendering/RenderGeometryMap.cpp (modified) (2 diffs)
• rendering/RenderGeometryMap.h (modified) (3 diffs)
• rendering/RenderGrid.cpp (modified) (18 diffs)
• rendering/RenderGrid.h (modified) (1 diff)
• rendering/RenderImageResource.h (modified) (1 diff)
• rendering/RenderLayer.cpp (modified) (18 diffs)
• rendering/RenderLayer.h (modified) (8 diffs)
• rendering/RenderLayerCompositor.cpp (modified) (3 diffs)
• rendering/RenderLayerCompositor.h (modified) (1 diff)
• rendering/RenderLayerFilterInfo.cpp (modified) (2 diffs)
• rendering/RenderLayerFilterInfo.h (modified) (4 diffs)
• rendering/RenderRegion.cpp (modified) (1 diff)
• rendering/RenderRegion.h (modified) (3 diffs)
• rendering/RenderTable.cpp (modified) (1 diff)
• rendering/RenderTable.h (modified) (2 diffs)
• rendering/RenderView.cpp (modified) (9 diffs)
• rendering/RenderView.h (modified) (2 diffs)
• rendering/RootInlineBox.h (modified) (2 diffs)
• rendering/TextAutosizer.h (modified) (1 diff)
• rendering/shapes/PolygonShape.cpp (modified) (2 diffs)
• rendering/shapes/PolygonShape.h (modified) (2 diffs)
• rendering/shapes/RasterShape.cpp (modified) (2 diffs)
• rendering/shapes/RasterShape.h (modified) (3 diffs)
• rendering/shapes/Shape.cpp (modified) (8 diffs)
• rendering/shapes/Shape.h (modified) (2 diffs)
• rendering/shapes/ShapeInfo.h (modified) (3 diffs)
• rendering/style/ContentData.h (modified) (1 diff)
• rendering/style/CounterDirectives.cpp (modified) (2 diffs)
• rendering/style/CounterDirectives.h (modified) (2 diffs)
• rendering/style/GridCoordinate.h (modified) (2 diffs)
• rendering/style/RenderStyle.cpp (modified) (4 diffs)
• rendering/style/RenderStyle.h (modified) (3 diffs)
• rendering/style/StyleRareNonInheritedData.cpp (modified) (1 diff)
• rendering/style/StyleRareNonInheritedData.h (modified) (3 diffs)
• rendering/svg/RenderSVGResourceGradient.cpp (modified) (1 diff)
• rendering/svg/RenderSVGResourceGradient.h (modified) (2 diffs)
• rendering/svg/RenderSVGResourcePattern.cpp (modified) (2 diffs)
• rendering/svg/RenderSVGResourcePattern.h (modified) (2 diffs)
• rendering/svg/RenderSVGShape.cpp (modified) (1 diff)
• rendering/svg/RenderSVGShape.h (modified) (2 diffs)
• rendering/svg/SVGResources.cpp (modified) (8 diffs)
• rendering/svg/SVGResources.h (modified) (4 diffs)
• rendering/svg/SVGResourcesCache.cpp (modified) (2 diffs)
• rendering/svg/SVGResourcesCache.h (modified) (2 diffs)
• rendering/svg/SVGTextMetricsBuilder.cpp (modified) (1 diff)
• rendering/svg/SVGTextMetricsBuilder.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-03-23  Zan Dobersek  <zdobersek@igalia.com>
+
+        Move Source/WebCore/rendering/ code to std::unique_ptr
+        https://bugs.webkit.org/show_bug.cgi?id=129664
+
+        Reviewed by Anders Carlsson.
+
+        Replace uses of OwnPtr and PassOwnPtr in code under Source/WebCore/rendering/ with std::unique_ptr.
+
+        * platform/graphics/FloatPolygon.cpp:
+        (WebCore::FloatPolygon::FloatPolygon):
+        * platform/graphics/FloatPolygon.h:
+        * rendering/ClipPathOperation.h:
+        * rendering/FlowThreadController.cpp:
+        (WebCore::FlowThreadController::ensureRenderFlowThreadWithName):
+        * rendering/FlowThreadController.h:
+        * rendering/HitTestLocation.h:
+        * rendering/HitTestResult.cpp:
+        (WebCore::HitTestResult::HitTestResult):
+        (WebCore::HitTestResult::operator=):
+        (WebCore::HitTestResult::rectBasedTestResult):
+        (WebCore::HitTestResult::mutableRectBasedTestResult):
+        * rendering/HitTestResult.h:
+        * rendering/HitTestingTransformState.cpp:
+        * rendering/ImageQualityController.h:
+        * rendering/RenderBlock.cpp:
+        (WebCore::removeBlockFromDescendantAndContainerMaps):
+        (WebCore::RenderBlock::finishDelayUpdateScrollInfo):
+        (WebCore::RenderBlock::addContinuationWithOutline):
+        (WebCore::RenderBlock::paintContinuationOutlines):
+        (WebCore::RenderBlock::insertIntoTrackedRendererMaps):
+        (WebCore::RenderBlock::removeFromTrackedRendererMaps):
+        (WebCore::RenderBlock::setComputedColumnCountAndWidth):
+        * rendering/RenderBlock.h:
+        * rendering/RenderBlockFlow.cpp:
+        (WebCore::RenderBlockFlow::createFloatingObjects):
+        * rendering/RenderBlockFlow.h:
+        * rendering/RenderBoxRegionInfo.h:
+        * rendering/RenderButton.cpp:
+        (WebCore::RenderButton::styleDidChange):
+        * rendering/RenderButton.h:
+        * rendering/RenderCounter.cpp:
+        (WebCore::makeCounterNode):
+        * rendering/RenderFlowThread.cpp:
+        (WebCore::RenderFlowThread::updateAllLayerToRegionMappings):
+        (WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock):
+        * rendering/RenderFlowThread.h:
+        * rendering/RenderGeometryMap.cpp:
+        (WebCore::RenderGeometryMap::push):
+        (WebCore::RenderGeometryMap::pushView):
+        * rendering/RenderGeometryMap.h:
+        * rendering/RenderGrid.cpp:
+        (WebCore::RenderGrid::GridIterator::nextEmptyGridArea):
+        (WebCore::RenderGrid::placeItemsOnGrid):
+        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
+        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+        (WebCore::RenderGrid::resolveGridPositionsFromStyle):
+        (WebCore::RenderGrid::resolveGridPositionAgainstOppositePosition):
+        (WebCore::RenderGrid::resolveNamedGridLinePositionAgainstOppositePosition):
+        (WebCore::RenderGrid::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
+        (WebCore::RenderGrid::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
+        * rendering/RenderGrid.h:
+        * rendering/RenderImageResource.h:
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::updateDescendantsAreContiguousInStackingOrder):
+        (WebCore::RenderLayer::updateTransform):
+        (WebCore::RenderLayer::setupFilters):
+        (WebCore::RenderLayer::paintLayerContents):
+        (WebCore::RenderLayer::paintChildLayerIntoColumns):
+        (WebCore::RenderLayer::hitTestChildLayerColumns):
+        (WebCore::RenderLayer::updateClipRects):
+        (WebCore::RenderLayer::calculateClipRects):
+        * rendering/RenderLayer.h:
+        (WebCore::RenderLayer::clearZOrderLists):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::notifyFlushBeforeDisplayRefresh):
+        (WebCore::RenderLayerCompositor::registerAllViewportConstrainedLayers):
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderLayerFilterInfo.cpp:
+        (WebCore::RenderLayer::FilterInfo::map):
+        (WebCore::RenderLayer::FilterInfo::get):
+        * rendering/RenderLayerFilterInfo.h:
+        * rendering/RenderRegion.cpp:
+        (WebCore::RenderRegion::setRenderBoxRegionInfo):
+        (WebCore::RenderRegion::takeRenderBoxRegionInfo):
+        * rendering/RenderRegion.h:
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::styleDidChange):
+        * rendering/RenderTable.h:
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::selectionBounds):
+        (WebCore::RenderView::setSelection):
+        (WebCore::RenderView::compositor):
+        (WebCore::RenderView::flowThreadController):
+        (WebCore::RenderView::imageQualityController):
+        * rendering/RenderView.h:
+        * rendering/RootInlineBox.h:
+        (WebCore::RootInlineBox::appendFloat):
+        * rendering/TextAutosizer.h:
+        * rendering/shapes/PolygonShape.cpp:
+        (WebCore::computeShapePaddingBounds):
+        (WebCore::computeShapeMarginBounds):
+        * rendering/shapes/PolygonShape.h:
+        (WebCore::PolygonShape::PolygonShape):
+        * rendering/shapes/RasterShape.cpp:
+        (WebCore::RasterShapeIntervals::computeShapeMarginIntervals):
+        * rendering/shapes/RasterShape.h:
+        (WebCore::RasterShape::RasterShape):
+        * rendering/shapes/Shape.cpp:
+        (WebCore::createInsetShape):
+        (WebCore::createRectangleShape):
+        (WebCore::createCircleShape):
+        (WebCore::createEllipseShape):
+        (WebCore::createPolygonShape):
+        (WebCore::Shape::createShape):
+        (WebCore::Shape::createRasterShape):
+        (WebCore::Shape::createLayoutBoxShape):
+        * rendering/shapes/Shape.h:
+        * rendering/shapes/ShapeInfo.h:
+        (WebCore::ShapeInfo::markShapeAsDirty):
+        (WebCore::ShapeInfo::isShapeDirty):
+        * rendering/shapes/ShapeInsideInfo.h:
+        * rendering/style/ContentData.h:
+        * rendering/style/CounterDirectives.cpp:
+        (WebCore::clone):
+        * rendering/style/CounterDirectives.h:
+        * rendering/style/GridCoordinate.h:
+        * rendering/style/RenderStyle.cpp:
+        (WebCore::RenderStyle::addCachedPseudoStyle):
+        (WebCore::RenderStyle::accessCounterDirectives):
+        (WebCore::RenderStyle::accessAnimations):
+        (WebCore::RenderStyle::accessTransitions):
+        * rendering/style/RenderStyle.h:
+        * rendering/style/StyleRareNonInheritedData.cpp:
+        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
+        * rendering/style/StyleRareNonInheritedData.h:
+        * rendering/svg/RenderSVGResourceGradient.cpp:
+        (WebCore::RenderSVGResourceGradient::applyResource):
+        * rendering/svg/RenderSVGResourceGradient.h:
+        * rendering/svg/RenderSVGResourcePattern.cpp:
+        (WebCore::RenderSVGResourcePattern::buildPattern):
+        * rendering/svg/RenderSVGResourcePattern.h:
+        * rendering/svg/RenderSVGShape.cpp:
+        (WebCore::RenderSVGShape::updateShapeFromElement):
+        * rendering/svg/RenderSVGShape.h:
+        * rendering/svg/SVGResources.cpp:
+        (WebCore::SVGResources::setClipper):
+        (WebCore::SVGResources::setFilter):
+        (WebCore::SVGResources::setMarkerStart):
+        (WebCore::SVGResources::setMarkerMid):
+        (WebCore::SVGResources::setMarkerEnd):
+        (WebCore::SVGResources::setMasker):
+        (WebCore::SVGResources::setFill):
+        (WebCore::SVGResources::setStroke):
+        * rendering/svg/SVGResources.h:
+        * rendering/svg/SVGResourcesCache.cpp:
+        (WebCore::SVGResourcesCache::addResourcesFromRenderer):
+        (WebCore::SVGResourcesCache::removeResourcesFromRenderer):
+        * rendering/svg/SVGResourcesCache.h:
+        * rendering/svg/SVGTextMetricsBuilder.cpp:
+        (WebCore::SVGTextMetricsBuilder::initializeMeasurementWithTextRenderer):
+        * rendering/svg/SVGTextMetricsBuilder.h:
+
 2014-03-28  Sergio Villar Senin  <svillar@igalia.com>
 

trunk/Source/WebCore/platform/graphics/FloatPolygon.cpp

@@ -80 +80 @@
 }
 
-FloatPolygon::FloatPolygon(PassOwnPtr<Vector<FloatPoint>> vertices, WindRule fillRule)
-    : m_vertices(vertices)
+FloatPolygon::FloatPolygon(std::unique_ptr<Vector<FloatPoint>> vertices, WindRule fillRule)
+    : m_vertices(std::move(vertices))
     , m_fillRule(fillRule)
 {

trunk/Source/WebCore/platform/graphics/FloatPolygon.h

@@ -36 +36 @@
 #include "ValueToString.h"
 #include "WindRule.h"
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
+#include <memory>
 #include <wtf/Vector.h>
 
@@ -46 +45 @@
 class FloatPolygon {
 public:
-    FloatPolygon(PassOwnPtr<Vector<FloatPoint>> vertices, WindRule fillRule);
+    FloatPolygon(std::unique_ptr<Vector<FloatPoint>> vertices, WindRule fillRule);
 
     const FloatPoint& vertexAt(unsigned index) const { return (*m_vertices)[index]; }
@@ -68 +67 @@
     bool containsEvenOdd(const FloatPoint&) const;
 
-    OwnPtr<Vector<FloatPoint>> m_vertices;
+    std::unique_ptr<Vector<FloatPoint>> m_vertices;
     WindRule m_fillRule;
     FloatRect m_boundingBox;

trunk/Source/WebCore/rendering/ClipPathOperation.h

@@ -34 +34 @@
 #include "Path.h"
 #include "RenderStyleConstants.h"
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/text/WTFString.h>

trunk/Source/WebCore/rendering/FlowThreadController.cpp

@@ -41 +41 @@
 namespace WebCore {
 
-PassOwnPtr<FlowThreadController> FlowThreadController::create(RenderView* view)
-{
-    return adoptPtr(new FlowThreadController(view));
-}
-
 FlowThreadController::FlowThreadController(RenderView* view)
     : m_view(view)
@@ -61 +56 @@
 {
     if (!m_renderNamedFlowThreadList)
-        m_renderNamedFlowThreadList = adoptPtr(new RenderNamedFlowThreadList());
+        m_renderNamedFlowThreadList = std::make_unique<RenderNamedFlowThreadList>();
     else {
         for (auto iter = m_renderNamedFlowThreadList->begin(), end = m_renderNamedFlowThreadList->end(); iter != end; ++iter) {

trunk/Source/WebCore/rendering/FlowThreadController.h

@@ -32 +32 @@
 
 #include "RenderView.h"
+#include <memory>
 #include <wtf/ListHashSet.h>
-#include <wtf/OwnPtr.h>
 
 namespace WebCore {
@@ -46 +46 @@
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    static PassOwnPtr<FlowThreadController> create(RenderView*);
+    explicit FlowThreadController(RenderView*);
     ~FlowThreadController();
 
@@ -92 +92 @@
 
 protected:
-    explicit FlowThreadController(RenderView*);
     void updateFlowThreadsChainIfNecessary();
     void resetFlowThreadsWithAutoHeightRegions();
@@ -101 +100 @@
     bool m_isRenderNamedFlowThreadOrderDirty;
     unsigned m_flowThreadsWithAutoLogicalHeightRegions;
-    OwnPtr<RenderNamedFlowThreadList> m_renderNamedFlowThreadList;
+    std::unique_ptr<RenderNamedFlowThreadList> m_renderNamedFlowThreadList;
     HashMap<const Element*, RenderNamedFlowThread*> m_mapNamedFlowContentElement;
 };

trunk/Source/WebCore/rendering/HitTestLocation.h

@@ -31 +31 @@
 #include <wtf/Forward.h>
 #include <wtf/ListHashSet.h>
-#include <wtf/OwnPtr.h>
 #include <wtf/RefPtr.h>
 

trunk/Source/WebCore/rendering/HitTestResult.cpp

@@ -93 +93 @@
 {
     // Only copy the NodeSet in case of rect hit test.
-    m_rectBasedTestResult = adoptPtr(other.m_rectBasedTestResult ? new NodeSet(*other.m_rectBasedTestResult) : 0);
+    m_rectBasedTestResult = other.m_rectBasedTestResult ? std::make_unique<NodeSet>(*other.m_rectBasedTestResult) : nullptr;
 }
 
@@ -112 +112 @@
 
     // Only copy the NodeSet in case of rect hit test.
-    m_rectBasedTestResult = adoptPtr(other.m_rectBasedTestResult ? new NodeSet(*other.m_rectBasedTestResult) : 0);
+    m_rectBasedTestResult = other.m_rectBasedTestResult ? std::make_unique<NodeSet>(*other.m_rectBasedTestResult) : nullptr;
 
     return *this;
@@ -638 +638 @@
 {
     if (!m_rectBasedTestResult)
-        m_rectBasedTestResult = adoptPtr(new NodeSet);
+        m_rectBasedTestResult = std::make_unique<NodeSet>();
     return *m_rectBasedTestResult;
 }
@@ -645 +645 @@
 {
     if (!m_rectBasedTestResult)
-        m_rectBasedTestResult = adoptPtr(new NodeSet);
+        m_rectBasedTestResult = std::make_unique<NodeSet>();
     return *m_rectBasedTestResult;
 }

trunk/Source/WebCore/rendering/HitTestResult.h

@@ -29 +29 @@
 #include "LayoutRect.h"
 #include "TextDirection.h"
+#include <memory>
 #include <wtf/Forward.h>
 #include <wtf/ListHashSet.h>
-#include <wtf/OwnPtr.h>
 #include <wtf/RefPtr.h>
 
@@ -159 +159 @@
     bool m_isOverWidget; // Returns true if we are over a widget (and not in the border/padding area of a RenderWidget for example).
 
-    mutable OwnPtr<NodeSet> m_rectBasedTestResult;
+    mutable std::unique_ptr<NodeSet> m_rectBasedTestResult;
 };
 

trunk/Source/WebCore/rendering/HitTestingTransformState.cpp

@@ -28 +28 @@
 
 #include "LayoutRect.h"
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {

trunk/Source/WebCore/rendering/ImageQualityController.h

@@ -29 +29 @@
 #include "Timer.h"
 #include <wtf/HashMap.h>
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
@@ -43 +42 @@
     WTF_MAKE_NONCOPYABLE(ImageQualityController)
 public:
-    static PassOwnPtr<ImageQualityController> create(const RenderView& renderView) { return adoptPtr(new ImageQualityController(renderView)); }
+    explicit ImageQualityController(const RenderView&);
 
     bool shouldPaintAtLowQuality(GraphicsContext*, RenderBoxModelObject*, Image*, const void* layer, const LayoutSize&);
@@ -51 +50 @@
     typedef HashMap<const void*, LayoutSize> LayerSizeMap;
     typedef HashMap<RenderBoxModelObject*, LayerSizeMap> ObjectLayerSizeMap;
-
-    explicit ImageQualityController(const RenderView&);
 
     void removeLayer(RenderBoxModelObject*, LayerSizeMap* innerMap, const void* layer);

trunk/Source/WebCore/rendering/RenderBlock.cpp

@@ -87 +87 @@
 COMPILE_ASSERT(sizeof(RenderBlock) == sizeof(SameSizeAsRenderBlock), RenderBlock_should_stay_small);
 
-typedef WTF::HashMap<const RenderBox*, OwnPtr<ColumnInfo>> ColumnInfoMap;
+typedef WTF::HashMap<const RenderBox*, std::unique_ptr<ColumnInfo>> ColumnInfoMap;
 static ColumnInfoMap* gColumnInfoMap = 0;
 
@@ -96 +96 @@
 static TrackedContainerMap* gPercentHeightContainerMap = 0;
     
-typedef WTF::HashMap<RenderBlock*, OwnPtr<ListHashSet<RenderInline*>>> ContinuationOutlineTableMap;
+typedef WTF::HashMap<RenderBlock*, std::unique_ptr<ListHashSet<RenderInline*>>> ContinuationOutlineTableMap;
 
 typedef WTF::HashSet<RenderBlock*> DelayedUpdateScrollInfoSet;
@@ -190 +190 @@
 static void removeBlockFromDescendantAndContainerMaps(RenderBlock* block, TrackedDescendantsMap*& descendantMap, TrackedContainerMap*& containerMap)
 {
-    if (OwnPtr<TrackedRendererListHashSet> descendantSet = descendantMap->take(block)) {
+    if (std::unique_ptr<TrackedRendererListHashSet> descendantSet = descendantMap->take(block)) {
         TrackedRendererListHashSet::iterator end = descendantSet->end();
         for (TrackedRendererListHashSet::iterator descendant = descendantSet->begin(); descendant != end; ++descendant) {
@@ -1225 +1225 @@
         ASSERT(gDelayedUpdateScrollInfoSet);
 
-        OwnPtr<DelayedUpdateScrollInfoSet> infoSet(adoptPtr(gDelayedUpdateScrollInfoSet));
+        std::unique_ptr<DelayedUpdateScrollInfoSet> infoSet(gDelayedUpdateScrollInfoSet);
         gDelayedUpdateScrollInfoSet = 0;
 
@@ -2227 +2227 @@
     if (!continuations) {
         continuations = new ListHashSet<RenderInline*>;
-        table->set(this, adoptPtr(continuations));
+        table->set(this, std::unique_ptr<ListHashSet<RenderInline*>>(continuations));
     }
     
@@ -2252 +2252 @@
         return;
         
-    OwnPtr<ListHashSet<RenderInline*>> continuations = table->take(this);
+    std::unique_ptr<ListHashSet<RenderInline*>> continuations = table->take(this);
     if (!continuations)
         return;
@@ -2657 +2657 @@
     if (!descendantSet) {
         descendantSet = new TrackedRendererListHashSet;
-        descendantsMap->set(this, adoptPtr(descendantSet));
+        descendantsMap->set(this, std::unique_ptr<TrackedRendererListHashSet>(descendantSet));
     }
     bool added = descendantSet->add(&descendant).isNewEntry;
@@ -2669 +2669 @@
     if (!containerSet) {
         containerSet = new HashSet<RenderBlock*>;
-        containerMap->set(&descendant, adoptPtr(containerSet));
+        containerMap->set(&descendant, std::unique_ptr<HashSet<RenderBlock*>>(containerSet));
     }
     ASSERT(!containerSet->contains(this));
@@ -2680 +2680 @@
         return;
     
-    OwnPtr<HashSet<RenderBlock*>> containerSet = containerMap->take(&descendant);
+    std::unique_ptr<HashSet<RenderBlock*>> containerSet = containerMap->take(&descendant);
     if (!containerSet)
         return;
@@ -3330 +3330 @@
                 gColumnInfoMap = new ColumnInfoMap;
             info = new ColumnInfo;
-            gColumnInfoMap->add(this, adoptPtr(info));
+            gColumnInfoMap->add(this, std::unique_ptr<ColumnInfo>(info));
             setHasColumns(true);
         }

trunk/Source/WebCore/rendering/RenderBlock.h

@@ -28 +28 @@
 #include "RenderBox.h"
 #include "TextRun.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 #include <wtf/ListHashSet.h>
 
@@ -43 +43 @@
 
 typedef WTF::ListHashSet<RenderBox*, 16> TrackedRendererListHashSet;
-typedef WTF::HashMap<const RenderBlock*, OwnPtr<TrackedRendererListHashSet>> TrackedDescendantsMap;
-typedef WTF::HashMap<const RenderBox*, OwnPtr<HashSet<RenderBlock*>>> TrackedContainerMap;
+typedef WTF::HashMap<const RenderBlock*, std::unique_ptr<TrackedRendererListHashSet>> TrackedDescendantsMap;
+typedef WTF::HashMap<const RenderBox*, std::unique_ptr<HashSet<RenderBlock*>>> TrackedContainerMap;
 
 enum CaretType { CursorCaret, DragCaret };

trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

@@ -2025 +2025 @@
 void RenderBlockFlow::createFloatingObjects()
 {
-    m_floatingObjects = adoptPtr(new FloatingObjects(*this));
+    m_floatingObjects = std::make_unique<FloatingObjects>(*this);
 }
 

trunk/Source/WebCore/rendering/RenderBlockFlow.h

@@ -29 +29 @@
 #include "SimpleLineLayout.h"
 #include "TrailingObjects.h"
+#include <memory>
 
 namespace WebCore {
@@ -593 +594 @@
 
 protected:
-    OwnPtr<FloatingObjects> m_floatingObjects;
+    std::unique_ptr<FloatingObjects> m_floatingObjects;
     std::unique_ptr<RenderBlockFlowRareData> m_rareBlockFlowData;
     RenderLineBoxList m_lineBoxes;

trunk/Source/WebCore/rendering/RenderBoxRegionInfo.h

@@ -29 +29 @@
 
 #include "RenderOverflow.h"
-#include <wtf/OwnPtr.h>
 
 namespace WebCore {

trunk/Source/WebCore/rendering/RenderButton.cpp

@@ -115 +115 @@
     if (!m_default && theme().isDefault(this)) {
         if (!m_timer)
-            m_timer = adoptPtr(new Timer<RenderButton>(this, &RenderButton::timerFired));
+            m_timer = std::make_unique<Timer<RenderButton>>(this, &RenderButton::timerFired);
         m_timer->startRepeating(0.03);
         m_default = true;
     } else if (m_default && !theme().isDefault(this)) {
         m_default = false;
-        m_timer.clear();
+        m_timer = nullptr;
     }
 }

trunk/Source/WebCore/rendering/RenderButton.h

@@ -24 +24 @@
 #include "RenderFlexibleBox.h"
 #include "Timer.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 
 namespace WebCore {
@@ -80 +80 @@
     RenderBlock* m_inner;
 
-    OwnPtr<Timer<RenderButton>> m_timer;
+    std::unique_ptr<Timer<RenderButton>> m_timer;
     bool m_default;
 };

trunk/Source/WebCore/rendering/RenderCounter.cpp

@@ -45 +45 @@
 
 typedef HashMap<AtomicString, RefPtr<CounterNode>> CounterMap;
-typedef HashMap<const RenderObject*, OwnPtr<CounterMap>> CounterMaps;
+typedef HashMap<const RenderObject*, std::unique_ptr<CounterMap>> CounterMaps;
 
 static CounterNode* makeCounterNode(RenderObject*, const AtomicString& identifier, bool alwaysCreateCounter);
@@ -325 +325 @@
     else {
         nodeMap = new CounterMap;
-        counterMaps().set(element, adoptPtr(nodeMap));
+        counterMaps().set(element, std::unique_ptr<CounterMap>(nodeMap));
         element->setHasCounterNodeMap(true);
     }

trunk/Source/WebCore/rendering/RenderFlowThread.cpp

@@ -324 +324 @@
     if (needsLayerUpdate) {
         if (!m_layerToRegionMap)
-            m_layerToRegionMap = adoptPtr(new LayerToRegionMap());
+            m_layerToRegionMap = std::make_unique<LayerToRegionMap>();
         m_layerToRegionMap->swap(layerToRegionMap);
 
         if (!m_regionToLayerListMap)
-            m_regionToLayerListMap = adoptPtr(new RegionToLayerListMap());
+            m_regionToLayerListMap = std::make_unique<RegionToLayerListMap>();
         m_regionToLayerListMap->swap(regionToLayerListMap);
     }
@@ -646 +646 @@
 
         // We have no information computed for this region so we need to do it.
-        OwnPtr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);
+        std::unique_ptr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);
         if (!oldInfo) {
             relayoutChildren = rangeInvalidated;

trunk/Source/WebCore/rendering/RenderFlowThread.h

@@ -304 +304 @@
 
     // Map a layer to the region in which the layer is painted.
-    OwnPtr<LayerToRegionMap> m_layerToRegionMap;
+    std::unique_ptr<LayerToRegionMap> m_layerToRegionMap;
 
     // Map a region to the list of layers that paint in that region.
-    OwnPtr<RegionToLayerListMap> m_regionToLayerListMap;
+    std::unique_ptr<RegionToLayerListMap> m_regionToLayerListMap;
 
     // Map a box to the list of regions in which the box is rendered.

trunk/Source/WebCore/rendering/RenderGeometryMap.cpp

@@ -230 +230 @@
     RenderGeometryMapStep& step = m_mapping[m_insertionPosition];
     if (!t.isIntegerTranslation())
-        step.m_transform = adoptPtr(new TransformationMatrix(t));
+        step.m_transform = std::make_unique<TransformationMatrix>(t);
     else
         step.m_offset = LayoutSize(t.e(), t.f());
@@ -247 +247 @@
     step.m_offset = scrollOffset;
     if (t)
-        step.m_transform = adoptPtr(new TransformationMatrix(*t));
+        step.m_transform = std::make_unique<TransformationMatrix>(*t);
     
     stepInserted(step);

trunk/Source/WebCore/rendering/RenderGeometryMap.h

@@ -33 +33 @@
 #include "RenderObject.h"
 #include "TransformationMatrix.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 
 namespace WebCore {
@@ -65 +65 @@
     const RenderObject* m_renderer;
     LayoutSize m_offset;
-    OwnPtr<TransformationMatrix> m_transform; // Includes offset if non-null.
+    std::unique_ptr<TransformationMatrix> m_transform; // Includes offset if non-null.
     bool m_accumulatingTransform;
     bool m_isNonUniform; // Mapping depends on the input point, e.g. because of CSS columns.
@@ -138 +138 @@
 
 namespace WTF {
-// This is required for a struct with OwnPtr. We know RenderGeometryMapStep is simple enough that
+// This is required for a struct with std::unique_ptr<>. We know RenderGeometryMapStep is simple enough that
 // initializing to 0 and moving with memcpy (and then not destructing the original) will work.
 template<> struct VectorTraits<WebCore::RenderGeometryMapStep> : SimpleClassVectorTraits { };

trunk/Source/WebCore/rendering/RenderGrid.cpp

@@ -118 +118 @@
     }
 
-    PassOwnPtr<GridCoordinate> nextEmptyGridArea()
+    std::unique_ptr<GridCoordinate> nextEmptyGridArea()
     {
         if (m_grid.isEmpty())
@@ -128 +128 @@
             const Vector<RenderBox*>& children = m_grid[m_rowIndex][m_columnIndex];
             if (children.isEmpty()) {
-                OwnPtr<GridCoordinate> result = adoptPtr(new GridCoordinate(GridSpan(m_rowIndex, m_rowIndex), GridSpan(m_columnIndex, m_columnIndex)));
+                std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan(m_rowIndex, m_rowIndex), GridSpan(m_columnIndex, m_columnIndex));
                 // Advance the iterator to avoid an infinite loop where we would return the same grid area over and over.
                 ++varyingTrackIndex;
-                return result.release();
+                return std::move(result);
             }
         }
@@ -671 +671 @@
         // FIXME: We never re-resolve positions if the grid is grown during auto-placement which may lead auto / <integer>
         // positions to not match the author's intent. The specification is unclear on what should be done in this case.
-        OwnPtr<GridSpan> rowPositions = resolveGridPositionsFromStyle(child, ForRows);
-        OwnPtr<GridSpan> columnPositions = resolveGridPositionsFromStyle(child, ForColumns);
+        std::unique_ptr<GridSpan> rowPositions = resolveGridPositionsFromStyle(child, ForRows);
+        std::unique_ptr<GridSpan> columnPositions = resolveGridPositionsFromStyle(child, ForColumns);
         if (!rowPositions || !columnPositions) {
             GridSpan* majorAxisPositions = (autoPlacementMajorAxisDirection() == ForColumns) ? columnPositions.get() : rowPositions.get();
@@ -713 +713 @@
 
         // This function bypasses the cache (cachedGridCoordinate()) as it is used to build it.
-        OwnPtr<GridSpan> rowPositions = resolveGridPositionsFromStyle(child, ForRows);
-        OwnPtr<GridSpan> columnPositions = resolveGridPositionsFromStyle(child, ForColumns);
+        std::unique_ptr<GridSpan> rowPositions = resolveGridPositionsFromStyle(child, ForRows);
+        std::unique_ptr<GridSpan> columnPositions = resolveGridPositionsFromStyle(child, ForColumns);
 
         // |positions| is 0 if we need to run the auto-placement algorithm. Our estimation ignores
@@ -734 +734 @@
 {
     for (size_t i = 0; i < autoGridItems.size(); ++i) {
-        OwnPtr<GridSpan> majorAxisPositions = resolveGridPositionsFromStyle(autoGridItems[i], autoPlacementMajorAxisDirection());
+        std::unique_ptr<GridSpan> majorAxisPositions = resolveGridPositionsFromStyle(autoGridItems[i], autoPlacementMajorAxisDirection());
         GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions->initialPositionIndex);
-        if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
+        if (std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
             insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
             continue;
@@ -742 +742 @@
 
         growGrid(autoPlacementMinorAxisDirection());
-        OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea();
+        std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea();
         ASSERT(emptyGridArea);
         insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
@@ -756 +756 @@
 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem)
 {
-    OwnPtr<GridSpan> minorAxisPositions = resolveGridPositionsFromStyle(gridItem, autoPlacementMinorAxisDirection());
+    std::unique_ptr<GridSpan> minorAxisPositions = resolveGridPositionsFromStyle(gridItem, autoPlacementMinorAxisDirection());
     ASSERT(!resolveGridPositionsFromStyle(gridItem, autoPlacementMajorAxisDirection()));
     size_t minorAxisIndex = 0;
@@ -762 +762 @@
         minorAxisIndex = minorAxisPositions->initialPositionIndex;
         GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisIndex);
-        if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
+        if (std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
             insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
             return;
@@ -770 +770 @@
         for (size_t majorAxisIndex = 0; majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
             GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisIndex);
-            if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
+            if (std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
                 insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
                 return;
@@ -949 +949 @@
 }
 
-PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionsFromStyle(const RenderBox* gridItem, GridTrackSizingDirection direction) const
+std::unique_ptr<GridSpan> RenderGrid::resolveGridPositionsFromStyle(const RenderBox* gridItem, GridTrackSizingDirection direction) const
 {
     GridPosition initialPosition = (direction == ForColumns) ? gridItem->style().gridItemColumnStart() : gridItem->style().gridItemRowStart();
@@ -960 +960 @@
     if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()) {
         if (style().gridAutoFlow() == AutoFlowNone)
-            return adoptPtr(new GridSpan(0, 0));
+            return std::make_unique<GridSpan>(0, 0);
 
         // We can't get our grid positions without running the auto placement algorithm.
@@ -985 +985 @@
         resolvedFinalPosition = resolvedInitialPosition;
 
-    return adoptPtr(new GridSpan(resolvedInitialPosition, resolvedFinalPosition));
+    return std::make_unique<GridSpan>(resolvedInitialPosition, resolvedFinalPosition);
 }
 
@@ -1060 +1060 @@
 }
 
-PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
+std::unique_ptr<GridSpan> RenderGrid::resolveGridPositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
 {
     if (position.isAuto())
-        return GridSpan::create(resolvedOppositePosition, resolvedOppositePosition);
+        return std::make_unique<GridSpan>(resolvedOppositePosition, resolvedOppositePosition);
 
     ASSERT(position.isSpan());
@@ -1078 +1078 @@
     if (side == ColumnStartSide || side == RowStartSide) {
         size_t initialResolvedPosition = std::max<int>(0, resolvedOppositePosition - positionOffset);
-        return GridSpan::create(initialResolvedPosition, resolvedOppositePosition);
-    }
-
-    return GridSpan::create(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
-}
-
-PassOwnPtr<GridSpan> RenderGrid::resolveNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
+        return std::make_unique<GridSpan>(initialResolvedPosition, resolvedOppositePosition);
+    }
+
+    return std::make_unique<GridSpan>(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
+}
+
+std::unique_ptr<GridSpan> RenderGrid::resolveNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
 {
     ASSERT(position.isSpan());
@@ -1097 +1097 @@
     // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
     if (it == gridLinesNames.end())
-        return GridSpan::create(resolvedOppositePosition, resolvedOppositePosition);
+        return std::make_unique<GridSpan>(resolvedOppositePosition, resolvedOppositePosition);
 
     if (side == RowStartSide || side == ColumnStartSide)
@@ -1121 +1121 @@
 }
 
-PassOwnPtr<GridSpan> RenderGrid::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines) const
+std::unique_ptr<GridSpan> RenderGrid::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines) const
 {
     size_t gridLineIndex = std::max<int>(0, firstNamedGridLineBeforePosition(resolvedOppositePosition, gridLines) - position.spanPosition() + 1);
@@ -1127 +1127 @@
     if (resolvedGridLinePosition > resolvedOppositePosition)
         resolvedGridLinePosition = resolvedOppositePosition;
-    return GridSpan::create(resolvedGridLinePosition, resolvedOppositePosition);
-}
-
-PassOwnPtr<GridSpan> RenderGrid::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines) const
+    return std::make_unique<GridSpan>(resolvedGridLinePosition, resolvedOppositePosition);
+}
+
+std::unique_ptr<GridSpan> RenderGrid::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines) const
 {
     size_t firstLineAfterOppositePositionIndex = gridLines.size() - 1;
@@ -1141 +1141 @@
     if (resolvedGridLinePosition < resolvedOppositePosition)
         resolvedGridLinePosition = resolvedOppositePosition;
-    return GridSpan::create(resolvedOppositePosition, resolvedGridLinePosition);
+    return std::make_unique<GridSpan>(resolvedOppositePosition, resolvedGridLinePosition);
 }
 

trunk/Source/WebCore/rendering/RenderGrid.h

@@ -114 +114 @@
     void adjustNamedGridItemPosition(GridPosition&, GridPositionSide) const;
     void adjustGridPositionsFromStyle(GridPosition& initialPosition, GridPosition& finalPosition, GridPositionSide initialPositionSide, GridPositionSide finalPositionSide) const;
-    PassOwnPtr<GridSpan> resolveGridPositionsFromStyle(const RenderBox*, GridTrackSizingDirection) const;
+    std::unique_ptr<GridSpan> resolveGridPositionsFromStyle(const RenderBox*, GridTrackSizingDirection) const;
     size_t resolveNamedGridLinePositionFromStyle(const GridPosition&, GridPositionSide) const;
     size_t resolveGridPositionFromStyle(const GridPosition&, GridPositionSide) const;
-    PassOwnPtr<GridSpan> resolveGridPositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, GridPositionSide) const;
-    PassOwnPtr<GridSpan> resolveNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, GridPositionSide) const;
-    PassOwnPtr<GridSpan> resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, const Vector<size_t>&) const;
-    PassOwnPtr<GridSpan> resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, const Vector<size_t>&) const;
+    std::unique_ptr<GridSpan> resolveGridPositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, GridPositionSide) const;
+    std::unique_ptr<GridSpan> resolveNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, GridPositionSide) const;
+    std::unique_ptr<GridSpan> resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, const Vector<size_t>&) const;
+    std::unique_ptr<GridSpan> resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition&, const Vector<size_t>&) const;
 
     LayoutUnit gridAreaBreadthForChild(const RenderBox* child, GridTrackSizingDirection, const Vector<GridTrack>&) const;

trunk/Source/WebCore/rendering/RenderImageResource.h

@@ -30 +30 @@
 #include "CachedResourceHandle.h"
 #include "StyleImage.h"
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {

trunk/Source/WebCore/rendering/RenderLayer.cpp

@@ -618 +618 @@
     ASSERT(!m_zOrderListsDirty);
 
-    OwnPtr<Vector<RenderLayer*>> posZOrderList;
-    OwnPtr<Vector<RenderLayer*>> negZOrderList;
+    std::unique_ptr<Vector<RenderLayer*>> posZOrderList;
+    std::unique_ptr<Vector<RenderLayer*>> negZOrderList;
     rebuildZOrderLists(StopAtStackingContexts, posZOrderList, negZOrderList);
 
@@ -865 +865 @@
     bool had3DTransform = has3DTransform();
 
-    bool hadTransform = m_transform;
+    bool hadTransform = !!m_transform;
     if (hasTransform != hadTransform) {
         if (hasTransform)
-            m_transform = adoptPtr(new TransformationMatrix);
+            m_transform = std::make_unique<TransformationMatrix>();
         else
-            m_transform.clear();
+            m_transform = nullptr;
         
         // Layers with transforms act as clip rects roots, so clear the cached clip rects here.
@@ -3928 +3928 @@
 #if ENABLE(CSS_FILTERS)
 
-PassOwnPtr<FilterEffectRendererHelper> RenderLayer::setupFilters(GraphicsContext* context, LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
+std::unique_ptr<FilterEffectRendererHelper> RenderLayer::setupFilters(GraphicsContext* context, LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
 {
     if (context->paintingDisabled())
@@ -3941 +3941 @@
         return nullptr;
 
-    OwnPtr<FilterEffectRendererHelper> filterPainter = adoptPtr(new FilterEffectRendererHelper(hasPaintedFilter));
+    auto filterPainter = std::make_unique<FilterEffectRendererHelper>(hasPaintedFilter);
     if (!filterPainter->haveFilterEffect())
         return nullptr;
@@ -3968 +3968 @@
         // Note that we will still apply the clipping on the final rendering of the filter.
         paintingInfo.clipToDirtyRect = !filterInfo->renderer()->hasFilterThatMovesPixels();
-        return filterPainter.release();
+        return std::move(filterPainter);
     }
     return nullptr;
@@ -4073 +4073 @@
     GraphicsContext* transparencyLayerContext = context;
 #if ENABLE(CSS_FILTERS)
-    OwnPtr<FilterEffectRendererHelper> filterPainter = setupFilters(context, localPaintingInfo, paintFlags, offsetFromRoot, rootRelativeBounds, rootRelativeBoundsComputed);
+    std::unique_ptr<FilterEffectRendererHelper> filterPainter = setupFilters(context, localPaintingInfo, paintFlags, offsetFromRoot, rootRelativeBounds, rootRelativeBoundsComputed);
     if (filterPainter) {
         context = filterPainter->filterContext();
@@ -4161 +4161 @@
     if (filterPainter) {
         context = applyFilters(filterPainter.get(), transparencyLayerContext, localPaintingInfo, layerFragments);
-        filterPainter.clear();
+        filterPainter = nullptr;
     }
 #endif
@@ -4578 +4578 @@
                 newTransform.translateRight(roundToInt(offset.width()), roundToInt(offset.height()));
                 
-                childLayer->m_transform = adoptPtr(new TransformationMatrix(newTransform));
+                childLayer->m_transform = std::make_unique<TransformationMatrix>(newTransform);
                 
                 LayerPaintingInfo localPaintingInfo(paintingInfo);
@@ -4585 +4585 @@
 
                 if (oldHasTransform)
-                    childLayer->m_transform = adoptPtr(new TransformationMatrix(oldTransform));
+                    childLayer->m_transform = std::make_unique<TransformationMatrix>(oldTransform);
                 else
-                    childLayer->m_transform.clear();
+                    childLayer->m_transform = nullptr;
             } else {
                 // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
@@ -5232 +5232 @@
                 newTransform.translateRight(offset.width(), offset.height());
 
-                childLayer->m_transform = adoptPtr(new TransformationMatrix(newTransform));
+                childLayer->m_transform = std::make_unique<TransformationMatrix>(newTransform);
                 hitLayer = childLayer->hitTestLayer(rootLayer, columnLayers[0], request, result, localClipRect, hitTestLocation, false, transformState, zOffset);
                 if (oldHasTransform)
-                    childLayer->m_transform = adoptPtr(new TransformationMatrix(oldTransform));
+                    childLayer->m_transform = std::make_unique<TransformationMatrix>(oldTransform);
                 else
-                    childLayer->m_transform.clear();
+                    childLayer->m_transform = nullptr;
             } else {
                 // Adjust the transform such that the renderer's upper left corner will be at (0,0) in user space.
@@ -5295 +5295 @@
 
     if (!m_clipRectsCache)
-        m_clipRectsCache = adoptPtr(new ClipRectsCache);
+        m_clipRectsCache = std::make_unique<ClipRectsCache>();
 
     if (parentLayer && parentLayer->clipRects(clipRectsContext) && clipRects == *parentLayer->clipRects(clipRectsContext))
@@ -5925 +5925 @@
 {
     if (!m_backing) {
-        m_backing = adoptPtr(new RenderLayerBacking(*this));
+        m_backing = std::make_unique<RenderLayerBacking>(*this);
         compositor().layerBecameComposited(*this);
 
@@ -5942 +5942 @@
     if (m_backing && !renderer().documentBeingDestroyed())
         compositor().layerBecameNonComposited(*this);
-    m_backing.clear();
+    m_backing = nullptr;
 
 #if ENABLE(CSS_FILTERS)
@@ -6116 +6116 @@
 }
 
-void RenderLayer::rebuildZOrderLists(CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*>>& posZOrderList, OwnPtr<Vector<RenderLayer*>>& negZOrderList)
+void RenderLayer::rebuildZOrderLists(CollectLayersBehavior behavior, std::unique_ptr<Vector<RenderLayer*>>& posZOrderList, std::unique_ptr<Vector<RenderLayer*>>& negZOrderList)
 {
     bool includeHiddenLayers = compositor().inCompositingMode();
@@ -6142 +6142 @@
         if (child->isNormalFlowOnly() && (!m_reflection || reflectionLayer() != child)) {
             if (!m_normalFlowList)
-                m_normalFlowList = adoptPtr(new Vector<RenderLayer*>);
+                m_normalFlowList = std::make_unique<Vector<RenderLayer*>>();
             m_normalFlowList->append(child);
         }
@@ -6150 +6150 @@
 }
 
-void RenderLayer::collectLayers(bool includeHiddenLayers, CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*>>& posBuffer, OwnPtr<Vector<RenderLayer*>>& negBuffer)
+void RenderLayer::collectLayers(bool includeHiddenLayers, CollectLayersBehavior behavior, std::unique_ptr<Vector<RenderLayer*>>& posBuffer, std::unique_ptr<Vector<RenderLayer*>>& negBuffer)
 {
     updateDescendantDependentFlags();
@@ -6159 +6159 @@
     if (includeHiddenLayer && !isNormalFlowOnly()) {
         // Determine which buffer the child should be in.
-        OwnPtr<Vector<RenderLayer*>>& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
+        std::unique_ptr<Vector<RenderLayer*>>& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
 
         // Create the buffer if it doesn't exist yet.
         if (!buffer)
-            buffer = adoptPtr(new Vector<RenderLayer*>);
+            buffer = std::make_unique<Vector<RenderLayer*>>();
         
         // Append ourselves at the end of the appropriate buffer.
@@ -6552 +6552 @@
     if (renderer().style().overflowX() == OMARQUEE && renderer().style().marqueeBehavior() != MNONE && renderer().isBox()) {
         if (!m_marquee)
-            m_marquee = adoptPtr(new RenderMarquee(this));
+            m_marquee = std::make_unique<RenderMarquee>(this);
         m_marquee->updateMarqueeStyle();
     }
     else if (m_marquee) {
-        m_marquee.clear();
+        m_marquee = nullptr;
     }
 

trunk/Source/WebCore/rendering/RenderLayer.h

@@ -50 +50 @@
 #include "RenderPtr.h"
 #include "ScrollableArea.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 
 namespace WebCore {
@@ -903 +903 @@
     void updateZOrderLists();
     void rebuildZOrderLists();
-    void rebuildZOrderLists(CollectLayersBehavior, OwnPtr<Vector<RenderLayer*>>&, OwnPtr<Vector<RenderLayer*>>&);
+    void rebuildZOrderLists(CollectLayersBehavior, std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&);
     void clearZOrderLists();
 
@@ -971 +971 @@
     LayoutPoint renderBoxLocation() const { return renderer().isBox() ? toRenderBox(renderer()).location() : LayoutPoint(); }
 
-    void collectLayers(bool includeHiddenLayers, CollectLayersBehavior, OwnPtr<Vector<RenderLayer*>>&, OwnPtr<Vector<RenderLayer*>>&);
+    void collectLayers(bool includeHiddenLayers, CollectLayersBehavior, std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&);
 
     void updateCompositingAndLayerListsIfNeeded();
@@ -999 +999 @@
     bool setupClipPath(GraphicsContext*, const LayerPaintingInfo&, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
 #if ENABLE(CSS_FILTERS)
-    PassOwnPtr<FilterEffectRendererHelper> setupFilters(GraphicsContext*, LayerPaintingInfo&, PaintLayerFlags, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
+    std::unique_ptr<FilterEffectRendererHelper> setupFilters(GraphicsContext*, LayerPaintingInfo&, PaintLayerFlags, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
     GraphicsContext* applyFilters(FilterEffectRendererHelper*, GraphicsContext* originalContext, LayerPaintingInfo&, LayerFragments&);
 #endif
@@ -1326 +1326 @@
     // (auto will count as 0).  m_negZOrderList holds descendants within our stacking context with negative
     // z-indices.
-    OwnPtr<Vector<RenderLayer*>> m_posZOrderList;
-    OwnPtr<Vector<RenderLayer*>> m_negZOrderList;
+    std::unique_ptr<Vector<RenderLayer*>> m_posZOrderList;
+    std::unique_ptr<Vector<RenderLayer*>> m_negZOrderList;
 
     // This list contains child layers that cannot create stacking contexts.  For now it is just
     // overflow layers, but that may change in the future.
-    OwnPtr<Vector<RenderLayer*>> m_normalFlowList;
-
-    OwnPtr<ClipRectsCache> m_clipRectsCache;
+    std::unique_ptr<Vector<RenderLayer*>> m_normalFlowList;
+
+    std::unique_ptr<ClipRectsCache> m_clipRectsCache;
     
     IntPoint m_cachedOverlayScrollbarOffset;
 
-    OwnPtr<RenderMarquee> m_marquee; // Used by layers with overflow:marquee
+    std::unique_ptr<RenderMarquee> m_marquee; // Used by layers with overflow:marquee
     
     // Cached normal flow values for absolute positioned elements with static left/top values.
@@ -1343 +1343 @@
     LayoutUnit m_staticBlockPosition;
 
-    OwnPtr<TransformationMatrix> m_transform;
+    std::unique_ptr<TransformationMatrix> m_transform;
     
     // May ultimately be extended to many replicas (with their own paint order).
@@ -1357 +1357 @@
     IntRect m_blockSelectionGapsBounds;
 
-    OwnPtr<RenderLayerBacking> m_backing;
+    std::unique_ptr<RenderLayerBacking> m_backing;
 
     class FilterInfo;
@@ -1366 +1366 @@
     ASSERT(!isStackingContainer());
 
-    m_posZOrderList.clear();
-    m_negZOrderList.clear();
+    m_posZOrderList = nullptr;
+    m_negZOrderList = nullptr;
 }
 

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -537 +537 @@
             displayID = page->chrome().displayID();
 
-        m_layerUpdater = adoptPtr(new GraphicsLayerUpdater(this, displayID));
+        m_layerUpdater = std::make_unique<GraphicsLayerUpdater>(this, displayID);
     }
     
@@ -3543 +3543 @@
 
 #if PLATFORM(IOS)
-typedef HashMap<PlatformLayer*, OwnPtr<ViewportConstraints>> LayerMap;
+typedef HashMap<PlatformLayer*, std::unique_ptr<ViewportConstraints>> LayerMap;
 typedef HashMap<PlatformLayer*, PlatformLayer*> StickyContainerMap;
 
@@ -3575 +3575 @@
             continue;
 
-        layerMap.add(layer.backing()->graphicsLayer()->platformLayer(), adoptPtr(constraints.release()));
+        layerMap.add(layer.backing()->graphicsLayer()->platformLayer(), std::move(constraints));
     }
     

trunk/Source/WebCore/rendering/RenderLayerCompositor.h

@@ -502 +502 @@
 #endif
 
-    OwnPtr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
+    std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
 
     Timer<RenderLayerCompositor> m_layerFlushTimer;

trunk/Source/WebCore/rendering/RenderLayerFilterInfo.cpp

@@ -44 +44 @@
 namespace WebCore {
 
-HashMap<const RenderLayer*, OwnPtr<RenderLayer::FilterInfo>>& RenderLayer::FilterInfo::map()
+HashMap<const RenderLayer*, std::unique_ptr<RenderLayer::FilterInfo>>& RenderLayer::FilterInfo::map()
 {
-    static NeverDestroyed<HashMap<const RenderLayer*, OwnPtr<FilterInfo>>> map;
+    static NeverDestroyed<HashMap<const RenderLayer*, std::unique_ptr<FilterInfo>>> map;
     return map;
 }
@@ -61 +61 @@
     ASSERT(layer.m_hasFilterInfo == map().contains(&layer));
 
-    OwnPtr<FilterInfo>& info = map().add(&layer, nullptr).iterator->value;
+    auto& info = map().add(&layer, nullptr).iterator->value;
     if (!info) {
-        info = adoptPtr(new FilterInfo(layer));
+        info = std::make_unique<FilterInfo>(layer);
         layer.m_hasFilterInfo = true;
     }

trunk/Source/WebCore/rendering/RenderLayerFilterInfo.h

@@ -37 +37 @@
 #include "CachedSVGDocumentClient.h"
 #include "RenderLayer.h"
+#include <memory>
 
 namespace WebCore {
@@ -49 +50 @@
     static void remove(RenderLayer&);
 
+    explicit FilterInfo(RenderLayer&);
+    ~FilterInfo();
+
     const LayoutRect& dirtySourceRect() const { return m_dirtySourceRect; }
     void expandDirtySourceRect(const LayoutRect& rect) { m_dirtySourceRect.unite(rect); }
@@ -60 +64 @@
 
 private:
-    explicit FilterInfo(RenderLayer&);
-    ~FilterInfo();
-
     Element* layerElement() const;
 
@@ -69 +70 @@
     virtual void notifyFinished(CachedResource*) override;
 
-    static HashMap<const RenderLayer*, OwnPtr<FilterInfo>>& map();
+    static HashMap<const RenderLayer*, std::unique_ptr<FilterInfo>>& map();
 
 #if PLATFORM(IOS)

trunk/Source/WebCore/rendering/RenderRegion.cpp

@@ -335 +335 @@
     ASSERT(isValid());
 
-    OwnPtr<RenderBoxRegionInfo>& boxInfo = m_renderBoxRegionInfo.add(box, adoptPtr(new RenderBoxRegionInfo(logicalLeftInset, logicalRightInset, containingBlockChainIsInset))).iterator->value;
+    std::unique_ptr<RenderBoxRegionInfo>& boxInfo = m_renderBoxRegionInfo.add(box, std::make_unique<RenderBoxRegionInfo>(logicalLeftInset, logicalRightInset, containingBlockChainIsInset)).iterator->value;
     return boxInfo.get();
 }
 
-OwnPtr<RenderBoxRegionInfo> RenderRegion::takeRenderBoxRegionInfo(const RenderBox* box)
+std::unique_ptr<RenderBoxRegionInfo> RenderRegion::takeRenderBoxRegionInfo(const RenderBox* box)
 {
     return m_renderBoxRegionInfo.take(box);

trunk/Source/WebCore/rendering/RenderRegion.h

@@ -34 +34 @@
 #include "StyleInheritedData.h"
 #include "VisiblePosition.h"
+#include <memory>
 
 namespace WebCore {
@@ -71 +72 @@
     RenderBoxRegionInfo* setRenderBoxRegionInfo(const RenderBox*, LayoutUnit logicalLeftInset, LayoutUnit logicalRightInset,
         bool containingBlockChainIsInset);
-    OwnPtr<RenderBoxRegionInfo> takeRenderBoxRegionInfo(const RenderBox*);
+    std::unique_ptr<RenderBoxRegionInfo> takeRenderBoxRegionInfo(const RenderBox*);
     void removeRenderBoxRegionInfo(const RenderBox*);
 
@@ -173 +174 @@
     // is unique to the region. For now it just holds logical width information for RenderBlocks, but eventually
     // it will also hold a custom style for any box (for region styling).
-    typedef HashMap<const RenderBox*, OwnPtr<RenderBoxRegionInfo>> RenderBoxRegionInfoMap;
+    typedef HashMap<const RenderBox*, std::unique_ptr<RenderBoxRegionInfo>> RenderBoxRegionInfoMap;
     RenderBoxRegionInfoMap m_renderBoxRegionInfo;
 

trunk/Source/WebCore/rendering/RenderTable.cpp

@@ -114 +114 @@
         // explicit width is specified on the table.  Auto width implies auto table layout.
         if (style().tableLayout() == TFIXED && !style().logicalWidth().isAuto())
-            m_tableLayout = adoptPtr(new FixedTableLayout(this));
+            m_tableLayout = std::make_unique<FixedTableLayout>(this);
         else
-            m_tableLayout = adoptPtr(new AutoTableLayout(this));
+            m_tableLayout = std::make_unique<AutoTableLayout>(this);
     }
 

trunk/Source/WebCore/rendering/RenderTable.h

@@ -29 +29 @@
 #include "CollapsedBorderValue.h"
 #include "RenderBlock.h"
+#include <memory>
 #include <wtf/HashMap.h>
 #include <wtf/Vector.h>
@@ -341 +342 @@
     mutable RenderTableSection* m_firstBody;
 
-    OwnPtr<TableLayout> m_tableLayout;
+    std::unique_ptr<TableLayout> m_tableLayout;
 
     CollapsedBorderValues m_collapsedBorders;

trunk/Source/WebCore/rendering/RenderView.cpp

@@ -660 +660 @@
 IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
 {
-    typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo>> SelectionMap;
+    typedef HashMap<RenderObject*, std::unique_ptr<RenderSelectionInfo>> SelectionMap;
     SelectionMap selectedObjects;
 
@@ -668 +668 @@
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
-            selectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, clipToVisibleContent)));
+            selectedObjects.set(os, std::make_unique<RenderSelectionInfo>(os, clipToVisibleContent));
             RenderBlock* cb = os->containingBlock();
             while (cb && !cb->isRenderView()) {
-                OwnPtr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).iterator->value;
+                std::unique_ptr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).iterator->value;
                 if (blockInfo)
                     break;
-                blockInfo = adoptPtr(new RenderSelectionInfo(cb, clipToVisibleContent));
+                blockInfo = std::make_unique<RenderSelectionInfo>(cb, clipToVisibleContent);
                 cb = cb->containingBlock();
             }
@@ -774 +774 @@
 
     // Objects each have a single selection rect to examine.
-    typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo>> SelectedObjectMap;
+    typedef HashMap<RenderObject*, std::unique_ptr<RenderSelectionInfo>> SelectedObjectMap;
     SelectedObjectMap oldSelectedObjects;
     SelectedObjectMap newSelectedObjects;
@@ -781 +781 @@
     // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
     // the union of those rects might remain the same even when changes have occurred.
-    typedef HashMap<RenderBlock*, OwnPtr<RenderBlockSelectionInfo>> SelectedBlockMap;
+    typedef HashMap<RenderBlock*, std::unique_ptr<RenderBlockSelectionInfo>> SelectedBlockMap;
     SelectedBlockMap oldSelectedBlocks;
     SelectedBlockMap newSelectedBlocks;
@@ -792 +792 @@
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
-            oldSelectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, true)));
+            oldSelectedObjects.set(os, std::make_unique<RenderSelectionInfo>(os, true));
             if (blockRepaintMode == RepaintNewXOROld) {
                 RenderBlock* cb = os->containingBlock();
                 while (cb && !cb->isRenderView()) {
-                    OwnPtr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).iterator->value;
+                    std::unique_ptr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).iterator->value;
                     if (blockInfo)
                         break;
-                    blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
+                    blockInfo = std::make_unique<RenderBlockSelectionInfo>(cb);
                     cb = cb->containingBlock();
                 }
@@ -848 +848 @@
     while (continueExploring) {
         if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
-            newSelectedObjects.set(o, adoptPtr(new RenderSelectionInfo(o, true)));
+            newSelectedObjects.set(o, std::make_unique<RenderSelectionInfo>(o, true));
             RenderBlock* cb = o->containingBlock();
             while (cb && !cb->isRenderView()) {
-                OwnPtr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).iterator->value;
+                std::unique_ptr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).iterator->value;
                 if (blockInfo)
                     break;
-                blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
+                blockInfo = std::make_unique<RenderBlockSelectionInfo>(cb);
                 cb = cb->containingBlock();
             }
@@ -1093 +1093 @@
 {
     if (!m_compositor)
-        m_compositor = adoptPtr(new RenderLayerCompositor(*this));
+        m_compositor = std::make_unique<RenderLayerCompositor>(*this);
 
     return *m_compositor;
@@ -1124 +1124 @@
 {
     if (!m_flowThreadController)
-        m_flowThreadController = FlowThreadController::create(this);
+        m_flowThreadController = std::make_unique<FlowThreadController>(this);
 
     return *m_flowThreadController;
@@ -1163 +1163 @@
 {
     if (!m_imageQualityController)
-        m_imageQualityController = ImageQualityController::create(*this);
+        m_imageQualityController = std::make_unique<ImageQualityController>(*this);
     return *m_imageQualityController;
 }

trunk/Source/WebCore/rendering/RenderView.h

@@ -28 +28 @@
 #include "Region.h"
 #include "RenderBlockFlow.h"
+#include <memory>
 #include <wtf/HashSet.h>
-#include <wtf/OwnPtr.h>
 
 namespace WebCore {
@@ -322 +322 @@
     bool shouldUsePrintingLayout() const;
 
-    OwnPtr<ImageQualityController> m_imageQualityController;
+    std::unique_ptr<ImageQualityController> m_imageQualityController;
     LayoutUnit m_pageLogicalHeight;
     bool m_pageLogicalHeightChanged;
     std::unique_ptr<LayoutState> m_layoutState;
     unsigned m_layoutStateDisableCount;
-    OwnPtr<RenderLayerCompositor> m_compositor;
-    OwnPtr<FlowThreadController> m_flowThreadController;
+    std::unique_ptr<RenderLayerCompositor> m_compositor;
+    std::unique_ptr<FlowThreadController> m_flowThreadController;
     RefPtr<IntervalArena> m_intervalArena;
 

trunk/Source/WebCore/rendering/RootInlineBox.h

@@ -143 +143 @@
             m_floats->append(&floatingBox);
         else
-            m_floats = adoptPtr(new Vector<RenderBox*>(1, &floatingBox));
+            m_floats = std::make_unique<Vector<RenderBox*>>(1, &floatingBox);
     }
 
@@ -220 +220 @@
     // Floats hanging off the line are pushed into this vector during layout. It is only
     // good for as long as the line has not been marked dirty.
-    OwnPtr<Vector<RenderBox*>> m_floats;
+    std::unique_ptr<Vector<RenderBox*>> m_floats;
 };
 

trunk/Source/WebCore/rendering/TextAutosizer.h

@@ -32 +32 @@
 #include "WritingMode.h"
 #include <wtf/Noncopyable.h>
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {

trunk/Source/WebCore/rendering/shapes/PolygonShape.cpp

@@ -127 +127 @@
 }
 
-static inline PassOwnPtr<FloatPolygon> computeShapeMarginBounds(const FloatPolygon& polygon, float margin, WindRule fillRule)
-{
-    OwnPtr<Vector<FloatPoint>> marginVertices = adoptPtr(new Vector<FloatPoint>());
+static inline std::unique_ptr<FloatPolygon> computeShapeMarginBounds(const FloatPolygon& polygon, float margin, WindRule fillRule)
+{
+    auto marginVertices = std::make_unique<Vector<FloatPoint>>();
     FloatPoint intersection;
 
@@ -145 +145 @@
 
     snapVerticesToLayoutUnitGrid(*marginVertices);
-    return adoptPtr(new FloatPolygon(marginVertices.release(), fillRule));
+    return std::make_unique<FloatPolygon>(std::move(marginVertices), fillRule);
 }
 

trunk/Source/WebCore/rendering/shapes/PolygonShape.h

@@ -83 +83 @@
     WTF_MAKE_NONCOPYABLE(PolygonShape);
 public:
-    PolygonShape(PassOwnPtr<Vector<FloatPoint>> vertices, WindRule fillRule)
-        : m_polygon(vertices, fillRule)
+    PolygonShape(std::unique_ptr<Vector<FloatPoint>> vertices, WindRule fillRule)
+        : m_polygon(std::move(vertices), fillRule)
         , m_marginBounds(nullptr)
     {
@@ -99 +99 @@
 
     FloatPolygon m_polygon;
-    mutable OwnPtr<FloatPolygon> m_marginBounds;
+    mutable std::unique_ptr<FloatPolygon> m_marginBounds;
 };
 

trunk/Source/WebCore/rendering/shapes/RasterShape.cpp

@@ -164 +164 @@
 }
 
-PassOwnPtr<RasterShapeIntervals> RasterShapeIntervals::computeShapeMarginIntervals(int shapeMargin) const
+std::unique_ptr<RasterShapeIntervals> RasterShapeIntervals::computeShapeMarginIntervals(int shapeMargin) const
 {
     int marginIntervalsSize = (offset() > shapeMargin) ? size() : size() - offset() * 2 + shapeMargin * 2;
-    OwnPtr<RasterShapeIntervals> result = adoptPtr(new RasterShapeIntervals(marginIntervalsSize, std::max(shapeMargin, offset())));
+    auto result = std::make_unique<RasterShapeIntervals>(marginIntervalsSize, std::max(shapeMargin, offset()));
     MarginIntervalGenerator marginIntervalGenerator(shapeMargin);
 
@@ -194 +194 @@
     }
 
-    return result.release();
+    return result;
 }
 

trunk/Source/WebCore/rendering/shapes/RasterShape.h

@@ -53 +53 @@
     void getExcludedIntervals(int y1, int y2, IntShapeIntervals& result) const;
 
-    PassOwnPtr<RasterShapeIntervals> computeShapeMarginIntervals(int shapeMargin) const;
+    std::unique_ptr<RasterShapeIntervals> computeShapeMarginIntervals(int shapeMargin) const;
 
     void buildBoundsPath(Path&) const;
@@ -92 +92 @@
     WTF_MAKE_NONCOPYABLE(RasterShape);
 public:
-    RasterShape(PassOwnPtr<RasterShapeIntervals> intervals, const IntSize& marginRectSize)
-        : m_intervals(intervals)
+    RasterShape(std::unique_ptr<RasterShapeIntervals> intervals, const IntSize& marginRectSize)
+        : m_intervals(std::move(intervals))
         , m_marginRectSize(marginRectSize)
     {
@@ -112 +112 @@
     const RasterShapeIntervals& marginIntervals() const;
 
-    OwnPtr<RasterShapeIntervals> m_intervals;
-    mutable OwnPtr<RasterShapeIntervals> m_marginIntervals;
+    std::unique_ptr<RasterShapeIntervals> m_intervals;
+    mutable std::unique_ptr<RasterShapeIntervals> m_marginIntervals;
     IntSize m_marginRectSize;
 };

trunk/Source/WebCore/rendering/shapes/Shape.cpp

@@ -42 +42 @@
 #include "WindRule.h"
 #include <wtf/MathExtras.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
 
-static PassOwnPtr<Shape> createInsetShape(const FloatRoundedRect& bounds)
+static std::unique_ptr<Shape> createInsetShape(const FloatRoundedRect& bounds)
 {
     ASSERT(bounds.rect().width() >= 0 && bounds.rect().height() >= 0);
-    return adoptPtr(new BoxShape(bounds));
-}
-
-static PassOwnPtr<Shape> createCircleShape(const FloatPoint& center, float radius)
+    return std::make_unique<BoxShape>(bounds);
+}
+
+static std::unique_ptr<Shape> createCircleShape(const FloatPoint& center, float radius)
 {
     ASSERT(radius >= 0);
-    return adoptPtr(new RectangleShape(FloatRect(center.x() - radius, center.y() - radius, radius*2, radius*2), FloatSize(radius, radius)));
-}
-
-static PassOwnPtr<Shape> createEllipseShape(const FloatPoint& center, const FloatSize& radii)
+    return std::make_unique<RectangleShape>(FloatRect(center.x() - radius, center.y() - radius, radius*2, radius*2), FloatSize(radius, radius));
+}
+
+static std::unique_ptr<Shape> createEllipseShape(const FloatPoint& center, const FloatSize& radii)
 {
     ASSERT(radii.width() >= 0 && radii.height() >= 0);
-    return adoptPtr(new RectangleShape(FloatRect(center.x() - radii.width(), center.y() - radii.height(), radii.width()*2, radii.height()*2), radii));
-}
-
-static PassOwnPtr<Shape> createPolygonShape(PassOwnPtr<Vector<FloatPoint>> vertices, WindRule fillRule)
-{
-    return adoptPtr(new PolygonShape(vertices, fillRule));
+    return std::make_unique<RectangleShape>(FloatRect(center.x() - radii.width(), center.y() - radii.height(), radii.width()*2, radii.height()*2), radii);
+}
+
+static std::unique_ptr<Shape> createPolygonShape(std::unique_ptr<Vector<FloatPoint>> vertices, WindRule fillRule)
+{
+    return std::make_unique<PolygonShape>(std::move(vertices), fillRule);
 }
 
@@ -95 +93 @@
 }
 
-PassOwnPtr<Shape> Shape::createShape(const BasicShape* basicShape, const LayoutSize& logicalBoxSize, WritingMode writingMode, Length margin)
+std::unique_ptr<Shape> Shape::createShape(const BasicShape* basicShape, const LayoutSize& logicalBoxSize, WritingMode writingMode, Length margin)
 {
     ASSERT(basicShape);
@@ -102 +100 @@
     float boxWidth = horizontalWritingMode ? logicalBoxSize.width() : logicalBoxSize.height();
     float boxHeight = horizontalWritingMode ? logicalBoxSize.height() : logicalBoxSize.width();
-    OwnPtr<Shape> shape;
+    std::unique_ptr<Shape> shape;
 
     switch (basicShape->type()) {
@@ -134 +132 @@
         size_t valuesSize = values.size();
         ASSERT(!(valuesSize % 2));
-        OwnPtr<Vector<FloatPoint>> vertices = adoptPtr(new Vector<FloatPoint>(valuesSize / 2));
+        std::unique_ptr<Vector<FloatPoint>> vertices = std::make_unique<Vector<FloatPoint>>(valuesSize / 2);
         for (unsigned i = 0; i < valuesSize; i += 2) {
             FloatPoint vertex(
@@ -142 +140 @@
         }
 
-        shape = createPolygonShape(vertices.release(), polygon.windRule());
+        shape = createPolygonShape(std::move(vertices), polygon.windRule());
         break;
     }
@@ -176 +174 @@
     shape->m_margin = floatValueForLength(margin, 0);
 
-    return shape.release();
-}
-
-PassOwnPtr<Shape> Shape::createRasterShape(Image* image, float threshold, const LayoutRect& imageR, const LayoutRect& marginR, WritingMode writingMode, Length margin)
+    return shape;
+}
+
+std::unique_ptr<Shape> Shape::createRasterShape(Image* image, float threshold, const LayoutRect& imageR, const LayoutRect& marginR, WritingMode writingMode, Length margin)
 {
     IntRect imageRect = pixelSnappedIntRect(imageR);
     IntRect marginRect = pixelSnappedIntRect(marginR);
-    OwnPtr<RasterShapeIntervals> intervals = adoptPtr(new RasterShapeIntervals(marginRect.height(), -marginRect.y()));
+    auto intervals = std::make_unique<RasterShapeIntervals>(marginRect.height(), -marginRect.y());
     std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(imageRect.size());
 
@@ -215 +213 @@
     }
 
-    OwnPtr<RasterShape> rasterShape = adoptPtr(new RasterShape(intervals.release(), marginRect.size()));
+    auto rasterShape = std::make_unique<RasterShape>(std::move(intervals), marginRect.size());
     rasterShape->m_writingMode = writingMode;
     rasterShape->m_margin = floatValueForLength(margin, 0);
-    return rasterShape.release();
-}
-
-PassOwnPtr<Shape> Shape::createBoxShape(const RoundedRect& roundedRect, WritingMode writingMode, Length margin)
+    return std::move(rasterShape);
+}
+
+std::unique_ptr<Shape> Shape::createBoxShape(const RoundedRect& roundedRect, WritingMode writingMode, Length margin)
 {
     ASSERT(roundedRect.rect().width() >= 0 && roundedRect.rect().height() >= 0);
@@ -227 +225 @@
     FloatRect rect(0, 0, roundedRect.rect().width(), roundedRect.rect().height());
     FloatRoundedRect bounds(rect, roundedRect.radii());
-    OwnPtr<Shape> shape = adoptPtr(new BoxShape(bounds));
+    auto shape = std::make_unique<BoxShape>(bounds);
     shape->m_writingMode = writingMode;
     shape->m_margin = floatValueForLength(margin, 0);
 
-    return shape.release();
+    return std::move(shape);
 }
 

trunk/Source/WebCore/rendering/shapes/Shape.h

@@ -37 +37 @@
 #include "StyleImage.h"
 #include "WritingMode.h"
-#include <wtf/PassOwnPtr.h>
+#include <memory>
 #include <wtf/Vector.h>
 
@@ -68 +68 @@
     };
 
-    static PassOwnPtr<Shape> createShape(const BasicShape*, const LayoutSize& logicalBoxSize, WritingMode, Length margin);
-    static PassOwnPtr<Shape> createRasterShape(Image*, float threshold, const LayoutRect& imageRect, const LayoutRect& marginRect, WritingMode, Length margin);
-    static PassOwnPtr<Shape> createBoxShape(const RoundedRect&, WritingMode, Length margin);
+    static std::unique_ptr<Shape> createShape(const BasicShape*, const LayoutSize& logicalBoxSize, WritingMode, Length margin);
+    static std::unique_ptr<Shape> createRasterShape(Image*, float threshold, const LayoutRect& imageRect, const LayoutRect& marginRect, WritingMode, Length margin);
+    static std::unique_ptr<Shape> createBoxShape(const RoundedRect&, WritingMode, Length margin);
 
     virtual ~Shape() { }

trunk/Source/WebCore/rendering/shapes/ShapeInfo.h

@@ -38 +38 @@
 #include "Shape.h"
 #include "ShapeValue.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 #include <wtf/Vector.h>
 
@@ -91 +91 @@
     virtual bool lineOverlapsShapeBounds() const = 0;
 
-    void markShapeAsDirty() { m_shape.clear(); }
-    bool isShapeDirty() { return !m_shape.get(); }
+    void markShapeAsDirty() { m_shape = nullptr; }
+    bool isShapeDirty() { return !m_shape; }
     const RenderType& owner() const { return m_renderer; }
     LayoutSize referenceBoxLogicalSize() const { return m_referenceBoxLogicalSize; }
@@ -149 +149 @@
 
 private:
-    mutable OwnPtr<Shape> m_shape;
+    mutable std::unique_ptr<Shape> m_shape;
     LayoutSize m_referenceBoxLogicalSize;
 };

trunk/Source/WebCore/rendering/style/ContentData.h

@@ -29 +29 @@
 #include "StyleImage.h"
 #include "RenderPtr.h"
-#include <wtf/OwnPtr.h>
 
 namespace WebCore {

trunk/Source/WebCore/rendering/style/CounterDirectives.cpp

@@ -22 +22 @@
 #include "config.h"
 #include "CounterDirectives.h"
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
@@ -34 +33 @@
 }
 
-PassOwnPtr<CounterDirectiveMap> clone(const CounterDirectiveMap& counterDirectives)
+std::unique_ptr<CounterDirectiveMap> clone(const CounterDirectiveMap& counterDirectives)
 {
-    OwnPtr<CounterDirectiveMap> result = adoptPtr(new CounterDirectiveMap);
+    auto result = std::make_unique<CounterDirectiveMap>();
     *result = counterDirectives;
-    return result.release();
+    return std::move(result);
 }
 

trunk/Source/WebCore/rendering/style/CounterDirectives.h

@@ -26 +26 @@
 #define CounterDirectives_h
 
+#include <memory>
 #include <wtf/HashMap.h>
 #include <wtf/MathExtras.h>
@@ -105 +106 @@
 typedef HashMap<AtomicString, CounterDirectives> CounterDirectiveMap;
 
-PassOwnPtr<CounterDirectiveMap> clone(const CounterDirectiveMap&);
+std::unique_ptr<CounterDirectiveMap> clone(const CounterDirectiveMap&);
 
 } // namespace WebCore

trunk/Source/WebCore/rendering/style/GridCoordinate.h

@@ -36 +36 @@
 
 #include <wtf/HashMap.h>
-#include <wtf/PassOwnPtr.h>
 #include <wtf/text/WTFString.h>
 
@@ -46 +45 @@
 class GridSpan {
 public:
-    static PassOwnPtr<GridSpan> create(size_t initialPosition, size_t finalPosition)
-    {
-        return adoptPtr(new GridSpan(initialPosition, finalPosition));
-    }
-
     GridSpan(size_t initialPosition, size_t finalPosition)
         : initialPositionIndex(initialPosition)

trunk/Source/WebCore/rendering/style/RenderStyle.cpp

@@ -261 +261 @@
 
     if (!m_cachedPseudoStyles)
-        m_cachedPseudoStyles = adoptPtr(new PseudoStyleCache);
+        m_cachedPseudoStyles = std::make_unique<PseudoStyleCache>();
 
     m_cachedPseudoStyles->append(pseudo);
@@ -1114 +1114 @@
 CounterDirectiveMap& RenderStyle::accessCounterDirectives()
 {
-    OwnPtr<CounterDirectiveMap>& map = rareNonInheritedData.access()->m_counterDirectives;
+    auto& map = rareNonInheritedData.access()->m_counterDirectives;
     if (!map)
-        map = adoptPtr(new CounterDirectiveMap);
+        map = std::make_unique<CounterDirectiveMap>();
     return *map;
 }
@@ -1270 +1270 @@
 {
     if (!rareNonInheritedData.access()->m_animations)
-        rareNonInheritedData.access()->m_animations = adoptPtr(new AnimationList());
+        rareNonInheritedData.access()->m_animations = std::make_unique<AnimationList>();
     return rareNonInheritedData->m_animations.get();
 }
@@ -1277 +1277 @@
 {
     if (!rareNonInheritedData.access()->m_transitions)
-        rareNonInheritedData.access()->m_transitions = adoptPtr(new AnimationList());
+        rareNonInheritedData.access()->m_transitions = std::make_unique<AnimationList>();
     return rareNonInheritedData->m_transitions.get();
 }

trunk/Source/WebCore/rendering/style/RenderStyle.h

@@ -69 +69 @@
 #include "TransformOperations.h"
 #include "UnicodeBidi.h"
+#include <memory>
 #include <wtf/Forward.h>
-#include <wtf/OwnPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/StdLibExtras.h>
@@ -403 +403 @@
 
     // list of associated pseudo styles
-    OwnPtr<PseudoStyleCache> m_cachedPseudoStyles;
+    std::unique_ptr<PseudoStyleCache> m_cachedPseudoStyles;
 
     DataRef<SVGRenderStyle> m_svgStyle;
@@ -1554 +1554 @@
     void clearAnimations()
     {
-        rareNonInheritedData.access()->m_animations.clear();
+        rareNonInheritedData.access()->m_animations = nullptr;
     }
 
     void clearTransitions()
     {
-        rareNonInheritedData.access()->m_transitions.clear();
-    }
-
-    void inheritAnimations(const AnimationList* parent) { rareNonInheritedData.access()->m_animations = parent ? adoptPtr(new AnimationList(*parent)) : nullptr; }
-    void inheritTransitions(const AnimationList* parent) { rareNonInheritedData.access()->m_transitions = parent ? adoptPtr(new AnimationList(*parent)) : nullptr; }
+        rareNonInheritedData.access()->m_transitions = nullptr;
+    }
+
+    void inheritAnimations(const AnimationList* parent) { rareNonInheritedData.access()->m_animations = parent ? std::make_unique<AnimationList>(*parent) : nullptr; }
+    void inheritTransitions(const AnimationList* parent) { rareNonInheritedData.access()->m_transitions = parent ? std::make_unique<AnimationList>(*parent) : nullptr; }
     void adjustAnimations();
     void adjustTransitions();

trunk/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp

@@ -123 +123 @@
     , m_boxShadow(o.m_boxShadow ? std::make_unique<ShadowData>(*o.m_boxShadow) : nullptr)
     , m_boxReflect(o.m_boxReflect)
-    , m_animations(o.m_animations ? adoptPtr(new AnimationList(*o.m_animations)) : nullptr)
-    , m_transitions(o.m_transitions ? adoptPtr(new AnimationList(*o.m_transitions)) : nullptr)
+    , m_animations(o.m_animations ? std::make_unique<AnimationList>(*o.m_animations) : nullptr)
+    , m_transitions(o.m_transitions ? std::make_unique<AnimationList>(*o.m_transitions) : nullptr)
     , m_mask(o.m_mask)
     , m_maskBoxImage(o.m_maskBoxImage)

trunk/Source/WebCore/rendering/style/StyleRareNonInheritedData.h

@@ -35 +35 @@
 #include "NinePieceImage.h"
 #include "ShapeValue.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 #include <wtf/PassRefPtr.h>
 #include <wtf/Vector.h>
@@ -126 +126 @@
 
     std::unique_ptr<ContentData> m_content;
-    OwnPtr<CounterDirectiveMap> m_counterDirectives;
+    std::unique_ptr<CounterDirectiveMap> m_counterDirectives;
     String m_altText;
 
@@ -133 +133 @@
     RefPtr<StyleReflection> m_boxReflect;
 
-    OwnPtr<AnimationList> m_animations;
-    OwnPtr<AnimationList> m_transitions;
+    std::unique_ptr<AnimationList> m_animations;
+    std::unique_ptr<AnimationList> m_transitions;
 
     FillLayer m_mask;

trunk/Source/WebCore/rendering/svg/RenderSVGResourceGradient.cpp

@@ -121 +121 @@
         return false;
 
-    OwnPtr<GradientData>& gradientData = m_gradientMap.add(&renderer, nullptr).iterator->value;
+    auto& gradientData = m_gradientMap.add(&renderer, nullptr).iterator->value;
     if (!gradientData)
-        gradientData = adoptPtr(new GradientData);
+        gradientData = std::make_unique<GradientData>();
 
     bool isPaintingText = resourceMode & ApplyToTextMode;

trunk/Source/WebCore/rendering/svg/RenderSVGResourceGradient.h

@@ -27 +27 @@
 #include "RenderSVGResourceContainer.h"
 #include "SVGGradientElement.h"
-
+#include <memory>
 #include <wtf/HashMap.h>
 
@@ -68 +68 @@
 private:
     bool m_shouldCollectGradientAttributes : 1;
-    HashMap<RenderObject*, OwnPtr<GradientData>> m_gradientMap;
+    HashMap<RenderObject*, std::unique_ptr<GradientData>> m_gradientMap;
 
 #if USE(CG)

trunk/Source/WebCore/rendering/svg/RenderSVGResourcePattern.cpp

@@ -107 +107 @@
 
     // Build pattern.
-    OwnPtr<PatternData> patternData = adoptPtr(new PatternData);
+    auto patternData = std::make_unique<PatternData>();
     patternData->pattern = Pattern::create(copiedImage, true, true);
 
@@ -130 +130 @@
     // failures in the SVG image cache for example). To avoid having our PatternData deleted by
     // removeAllClientsFromCache(), we only make it visible in the cache at the very end.
-    return m_patternMap.set(object, patternData.release()).iterator->value.get();
+    return m_patternMap.set(object, std::move(patternData)).iterator->value.get();
 }
 

trunk/Source/WebCore/rendering/svg/RenderSVGResourcePattern.h

@@ -28 +28 @@
 #include "SVGPatternElement.h"
 #include "SVGUnitTypes.h"
-
+#include <memory>
 #include <wtf/HashMap.h>
 
@@ -67 +67 @@
     bool m_shouldCollectPatternAttributes : 1;
     PatternAttributes m_attributes;
-    HashMap<RenderObject*, OwnPtr<PatternData>> m_patternMap;
+    HashMap<RenderObject*, std::unique_ptr<PatternData>> m_patternMap;
 };
 

trunk/Source/WebCore/rendering/svg/RenderSVGShape.cpp

@@ -78 +78 @@
 void RenderSVGShape::updateShapeFromElement()
 {
-    m_path.clear();
-    m_path = adoptPtr(new Path);
+    m_path = std::make_unique<Path>();
     ASSERT(RenderSVGShape::isEmpty());
 

trunk/Source/WebCore/rendering/svg/RenderSVGShape.h

@@ -32 +32 @@
 #include "SVGGraphicsElement.h"
 #include "SVGMarkerData.h"
-#include <wtf/OwnPtr.h>
+#include <memory>
 #include <wtf/Vector.h>
 
@@ -125 +125 @@
     FloatRect m_repaintBoundingBoxExcludingShadow;
     AffineTransform m_localTransform;
-    OwnPtr<Path> m_path;
+    std::unique_ptr<Path> m_path;
     Vector<MarkerPosition> m_markerPositions;
 

trunk/Source/WebCore/rendering/svg/SVGResources.cpp

@@ -447 +447 @@
 
     if (!m_clipperFilterMaskerData)
-        m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
+        m_clipperFilterMaskerData = std::make_unique<ClipperFilterMaskerData>();
 
     m_clipperFilterMaskerData->clipper = clipper;
@@ -469 +469 @@
 
     if (!m_clipperFilterMaskerData)
-        m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
+        m_clipperFilterMaskerData = std::make_unique<ClipperFilterMaskerData>();
 
     m_clipperFilterMaskerData->filter = filter;
@@ -491 +491 @@
 
     if (!m_markerData)
-        m_markerData = MarkerData::create();
+        m_markerData = std::make_unique<MarkerData>();
 
     m_markerData->markerStart = markerStart;
@@ -512 +512 @@
 
     if (!m_markerData)
-        m_markerData = MarkerData::create();
+        m_markerData = std::make_unique<MarkerData>();
 
     m_markerData->markerMid = markerMid;
@@ -533 +533 @@
 
     if (!m_markerData)
-        m_markerData = MarkerData::create();
+        m_markerData = std::make_unique<MarkerData>();
 
     m_markerData->markerEnd = markerEnd;
@@ -554 +554 @@
 
     if (!m_clipperFilterMaskerData)
-        m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
+        m_clipperFilterMaskerData = std::make_unique<ClipperFilterMaskerData>();
 
     m_clipperFilterMaskerData->masker = masker;
@@ -577 +577 @@
 
     if (!m_fillStrokeData)
-        m_fillStrokeData = FillStrokeData::create();
+        m_fillStrokeData = std::make_unique<FillStrokeData>();
 
     m_fillStrokeData->fill = fill;
@@ -600 +600 @@
 
     if (!m_fillStrokeData)
-        m_fillStrokeData = FillStrokeData::create();
+        m_fillStrokeData = std::make_unique<FillStrokeData>();
 
     m_fillStrokeData->stroke = stroke;

trunk/Source/WebCore/rendering/svg/SVGResources.h

@@ -21 +21 @@
 #define SVGResources_h
 
+#include <memory>
 #include <wtf/HashSet.h>
 #include <wtf/Noncopyable.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
@@ -125 +124 @@
         }
 
-        static PassOwnPtr<ClipperFilterMaskerData> create()
-        {
-            return adoptPtr(new ClipperFilterMaskerData);
-        }
-
         RenderSVGResourceClipper* clipper;
 #if ENABLE(FILTERS)
@@ -147 +141 @@
             , markerEnd(0)
         {
-        }
-
-        static PassOwnPtr<MarkerData> create()
-        {
-            return adoptPtr(new MarkerData);
         }
 
@@ -172 +161 @@
         }
 
-        static PassOwnPtr<FillStrokeData> create()
-        {
-            return adoptPtr(new FillStrokeData);
-        }
-
         RenderSVGResourceContainer* fill;
         RenderSVGResourceContainer* stroke;
     };
 
-    OwnPtr<ClipperFilterMaskerData> m_clipperFilterMaskerData;
-    OwnPtr<MarkerData> m_markerData;
-    OwnPtr<FillStrokeData> m_fillStrokeData;
+    std::unique_ptr<ClipperFilterMaskerData> m_clipperFilterMaskerData;
+    std::unique_ptr<MarkerData> m_markerData;
+    std::unique_ptr<FillStrokeData> m_fillStrokeData;
     RenderSVGResourceContainer* m_linkedResource;
 };

trunk/Source/WebCore/rendering/svg/SVGResourcesCache.cpp

@@ -43 +43 @@
 
     // Build a list of all resources associated with the passed RenderObject
-    OwnPtr<SVGResources> newResources = adoptPtr(new SVGResources);
+    auto newResources = std::make_unique<SVGResources>();
     if (!newResources->buildCachedResources(renderer, svgStyle))
         return;
 
     // Put object in cache.
-    SVGResources& resources = *m_cache.add(&renderer, newResources.release()).iterator->value;
+    SVGResources& resources = *m_cache.add(&renderer, std::move(newResources)).iterator->value;
 
     // Run cycle-detection _afterwards_, so self-references can be caught as well.
@@ -64 +64 @@
 void SVGResourcesCache::removeResourcesFromRenderer(RenderElement& renderer)
 {
-    OwnPtr<SVGResources> resources = m_cache.take(&renderer);
+    std::unique_ptr<SVGResources> resources = m_cache.take(&renderer);
     if (!resources)
         return;

trunk/Source/WebCore/rendering/svg/SVGResourcesCache.h

@@ -22 +22 @@
 
 #include "RenderStyleConstants.h"
+#include <memory>
 #include <wtf/HashMap.h>
-#include <wtf/OwnPtr.h>
+#include <wtf/Noncopyable.h>
 
 namespace WebCore {
@@ -63 +64 @@
     void removeResourcesFromRenderer(RenderElement&);
 
-    typedef HashMap<const RenderObject*, OwnPtr<SVGResources>> CacheMap;
+    typedef HashMap<const RenderObject*, std::unique_ptr<SVGResources>> CacheMap;
     CacheMap m_cache;
 };

trunk/Source/WebCore/rendering/svg/SVGTextMetricsBuilder.cpp

@@ -105 +105 @@
 
     if (m_isComplexText)
-        m_simpleWidthIterator.clear();
+        m_simpleWidthIterator = nullptr;
     else
-        m_simpleWidthIterator = adoptPtr(new WidthIterator(&scaledFont, m_run));
+        m_simpleWidthIterator = std::make_unique<WidthIterator>(&scaledFont, m_run);
 }
 

trunk/Source/WebCore/rendering/svg/SVGTextMetricsBuilder.h

@@ -57 +57 @@
 
     // Simple text only.
-    OwnPtr<WidthIterator> m_simpleWidthIterator;
+    std::unique_ptr<WidthIterator> m_simpleWidthIterator;
 
     // Complex text only.