Remove OwnPtr from Blink.

third_party/WebKit/Source/core/layout/FloatingObjects.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 11 matching lines @@
  */
 
 #include "core/layout/FloatingObjects.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/shapes/ShapeOutsideInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/RuntimeEnabledFeatures.h"
-
+#include "wtf/PtrUtil.h"
 #include <algorithm>
+#include <memory>
 
 using namespace WTF;
 
 namespace blink {
 
 struct SameSizeAsFloatingObject {
     void* pointers[2];
     LayoutRect rect;
     uint32_t bitfields : 8;
 };
@@ skipping 37 matching lines @@
 bool FloatingObject::shouldPaintForCompositedLayoutPart()
 {
     // HACK: only non-self-painting floats should paint. However, due to the fundamental compositing bug, some LayoutPart objects
     // may become self-painting due to being composited. This leads to a chicken-egg issue because layout may not depend on compositing.
     // If this is the case, set shouldPaint() to true even if the layer is technically self-painting. This lets the float which contains
     // a LayoutPart start painting as soon as it stops being composited, without having to re-layout the float.
     // This hack can be removed after SPv2.
     return m_layoutObject->layer() && m_layoutObject->layer()->isSelfPaintingOnlyBecauseIsCompositedPart() && !RuntimeEnabledFeatures::slimmingPaintV2Enabled();
 }
 
-PassOwnPtr<FloatingObject> FloatingObject::create(LayoutBox* layoutObject)
+std::unique_ptr<FloatingObject> FloatingObject::create(LayoutBox* layoutObject)
 {
-    OwnPtr<FloatingObject> newObj = adoptPtr(new FloatingObject(layoutObject));
+    std::unique_ptr<FloatingObject> newObj = wrapUnique(new FloatingObject(layoutObject));
 
     // If a layer exists, the float will paint itself. Otherwise someone else will.
     newObj->setShouldPaint(!layoutObject->hasSelfPaintingLayer() || newObj->shouldPaintForCompositedLayoutPart());
 
     newObj->setIsDescendant(true);
 
     return newObj;
 }
 
 bool FloatingObject::shouldPaint() const
 {
     return m_shouldPaint && !m_layoutObject->hasSelfPaintingLayer();
 }
 
-PassOwnPtr<FloatingObject> FloatingObject::copyToNewContainer(LayoutSize offset, bool shouldPaint, bool isDescendant) const
+std::unique_ptr<FloatingObject> FloatingObject::copyToNewContainer(LayoutSize offset, bool shouldPaint, bool isDescendant) const
 {
-    return adoptPtr(new FloatingObject(layoutObject(), getType(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant, isLowestNonOverhangingFloatInChild()));
+    return wrapUnique(new FloatingObject(layoutObject(), getType(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant, isLowestNonOverhangingFloatInChild()));
 }
 
-PassOwnPtr<FloatingObject> FloatingObject::unsafeClone() const
+std::unique_ptr<FloatingObject> FloatingObject::unsafeClone() const
 {
-    OwnPtr<FloatingObject> cloneObject = adoptPtr(new FloatingObject(layoutObject(), getType(), m_frameRect, m_shouldPaint, m_isDescendant, false));
+    std::unique_ptr<FloatingObject> cloneObject = wrapUnique(new FloatingObject(layoutObject(), getType(), m_frameRect, m_shouldPaint, m_isDescendant, false));
     cloneObject->m_isPlaced = m_isPlaced;
     return cloneObject;
 }
 
 template <FloatingObject::Type FloatTypeValue>
 class ComputeFloatOffsetAdapter {
 public:
     typedef FloatingObjectInterval IntervalType;
 
     ComputeFloatOffsetAdapter(const LayoutBlockFlow* layoutObject, LayoutUnit lineTop, LayoutUnit lineBottom, LayoutUnit offset)
@@ skipping 273 matching lines @@
 
 void FloatingObjects::markLowestFloatLogicalBottomCacheAsDirty()
 {
     for (size_t i = 0; i < sizeof(m_lowestFloatBottomCache) / sizeof(FloatBottomCachedValue); ++i)
         m_lowestFloatBottomCache[i].dirty = true;
 }
 
 void FloatingObjects::moveAllToFloatInfoMap(LayoutBoxToFloatInfoMap& map)
 {
     while (!m_set.isEmpty()) {
-        OwnPtr<FloatingObject> floatingObject = m_set.takeFirst();
+        std::unique_ptr<FloatingObject> floatingObject = m_set.takeFirst();
         LayoutBox* layoutObject = floatingObject->layoutObject();
         map.add(layoutObject, std::move(floatingObject));
     }
     clear();
 }
 
 inline void FloatingObjects::increaseObjectsCount(FloatingObject::Type type)
 {
     if (type == FloatingObject::FloatLeft)
         m_leftObjectsCount++;
@@ skipping 39 matching lines @@
         ASSERT_UNUSED(removed, removed);
     }
 
     floatingObject.setIsPlaced(false);
 #if ENABLE(ASSERT)
     floatingObject.setIsInPlacedTree(false);
 #endif
     markLowestFloatLogicalBottomCacheAsDirty();
 }
 
-FloatingObject* FloatingObjects::add(PassOwnPtr<FloatingObject> floatingObject)
+FloatingObject* FloatingObjects::add(std::unique_ptr<FloatingObject> floatingObject)
 {
-    FloatingObject* newObject = floatingObject.leakPtr();
+    FloatingObject* newObject = floatingObject.release();
     increaseObjectsCount(newObject->getType());
-    m_set.add(adoptPtr(newObject));
+    m_set.add(wrapUnique(newObject));
     if (newObject->isPlaced())
         addPlacedObject(*newObject);
     markLowestFloatLogicalBottomCacheAsDirty();
     return newObject;
 }
 
 void FloatingObjects::remove(FloatingObject* toBeRemoved)
 {
     decreaseObjectsCount(toBeRemoved->getType());
-    OwnPtr<FloatingObject> floatingObject = m_set.take(toBeRemoved);
+    std::unique_ptr<FloatingObject> floatingObject = m_set.take(toBeRemoved);
     ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
     if (floatingObject->isPlaced())
         removePlacedObject(*floatingObject);
     markLowestFloatLogicalBottomCacheAsDirty();
     ASSERT(!floatingObject->originatingLine());
 }
 
 void FloatingObjects::computePlacedFloatsTree()
 {
     ASSERT(!m_placedFloatsTree.isInitialized());
@@ skipping 144 matching lines @@
 }
 
 String ValueToString<FloatingObject*>::toString(const FloatingObject* floatingObject)
 {
     return String::format("%p (%gx%g %gx%g)", floatingObject, floatingObject->frameRect().x().toFloat(), floatingObject->frameRect().y().toFloat(), floatingObject->frameRect().maxX().toFloat(), floatingObject->frameRect().maxY().toFloat());
 }
 #endif
 
 
 } // namespace blink