Remove OwnPtr from Blink.

third_party/WebKit/Source/core/paint/PaintLayer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 42 matching lines @@
 #include "core/paint/PaintLayerFragment.h"
 #include "core/paint/PaintLayerPainter.h"
 #include "core/paint/PaintLayerReflectionInfo.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "core/paint/PaintLayerStackingNode.h"
 #include "core/paint/PaintLayerStackingNodeIterator.h"
 #include "platform/graphics/CompositingReasons.h"
 #include "platform/graphics/SquashingDisallowedReasons.h"
 #include "public/platform/WebBlendMode.h"
 #include "wtf/Allocator.h"
-#include "wtf/OwnPtr.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 
 class CompositedLayerMapping;
 class ComputedStyle;
 class FilterEffectBuilder;
 class FilterOperations;
 class HitTestRequest;
 class HitTestResult;
 class HitTestingTransformState;
@@ skipping 18 matching lines @@
     TemporaryChange<CompositingQueryMode> m_disabler;
 };
 
 struct PaintLayerRareData {
     PaintLayerRareData();
     ~PaintLayerRareData();
 
     // Our current relative position offset.
     LayoutSize offsetForInFlowPosition;
 
-    OwnPtr<TransformationMatrix> transform;
+    std::unique_ptr<TransformationMatrix> transform;
 
     // Pointer to the enclosing Layer that caused us to be paginated. It is 0 if we are not paginated.
     //
     // See LayoutMultiColumnFlowThread and
     // https://sites.google.com/a/chromium.org/dev/developers/design-documents/multi-column-layout
     // for more information about the multicol implementation. It's important to understand the
     // difference between flow thread coordinates and visual coordinates when working with multicol
     // in Layer, since Layer is one of the few places where we have to worry about the
     // visual ones. Internally we try to use flow-thread coordinates whenever possible.
     PaintLayer* enclosingPaginationLayer;
 
     // These compositing reasons are updated whenever style changes, not while updating compositing layers.
     // They should not be used to infer the compositing state of this layer.
     CompositingReasons potentialCompositingReasonsFromStyle;
 
     // Once computed, indicates all that a layer needs to become composited using the CompositingReasons enum bitfield.
     CompositingReasons compositingReasons;
 
     // This captures reasons why a paint layer might be forced to be separately
     // composited rather than sharing a backing with another layer.
     SquashingDisallowedReasons squashingDisallowedReasons;
 
     // If the layer paints into its own backings, this keeps track of the backings.
     // It's nullptr if the layer is not composited or paints into grouped backing.
-    OwnPtr<CompositedLayerMapping> compositedLayerMapping;
+    std::unique_ptr<CompositedLayerMapping> compositedLayerMapping;
 
     // If the layer paints into grouped backing (i.e. squashed), this points to the
     // grouped CompositedLayerMapping. It's null if the layer is not composited or
     // paints into its own backing.
     CompositedLayerMapping* groupedMapping;
 
-    OwnPtr<PaintLayerReflectionInfo> reflectionInfo;
+    std::unique_ptr<PaintLayerReflectionInfo> reflectionInfo;
 
     Persistent<PaintLayerFilterInfo> filterInfo;
 
     // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
     LayoutSize subpixelAccumulation;
 };
 
 // PaintLayer is an old object that handles lots of unrelated operations.
 //
 // We want it to die at some point and be replaced by more focused objects,
@@ skipping 543 matching lines @@
 
     bool needsPaintPhaseDescendantBlockBackgrounds() const { return m_needsPaintPhaseDescendantBlockBackgrounds; }
     void setNeedsPaintPhaseDescendantBlockBackgrounds() { ASSERT(isSelfPaintingLayer()); m_needsPaintPhaseDescendantBlockBackgrounds = true; }
 
     PaintTiming* paintTiming();
 
     ClipRectsCache* clipRectsCache() const { return m_clipRectsCache.get(); }
     ClipRectsCache& ensureClipRectsCache() const
     {
         if (!m_clipRectsCache)
-            m_clipRectsCache = adoptPtr(new ClipRectsCache);
+            m_clipRectsCache = wrapUnique(new ClipRectsCache);
         return *m_clipRectsCache;
     }
     void clearClipRectsCache() const { m_clipRectsCache.reset(); }
 
     void dirty3DTransformedDescendantStatus();
     // Both updates the status, and returns true if descendants of this have 3d.
     bool update3DTransformedDescendantStatus();
     bool has3DTransformedDescendant() const { DCHECK(!m_3DTransformedDescendantStatusDirty); return m_has3DTransformedDescendant; }
 
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
@@ skipping 66 matching lines @@
 
     void updatePaginationRecursive(bool needsPaginationUpdate = false);
     void clearPaginationRecursive();
 
     void setNeedsRepaintInternal();
     void markCompositingContainerChainForNeedsRepaint();
 
     PaintLayerRareData& ensureRareData()
     {
         if (!m_rareData)
-            m_rareData = adoptPtr(new PaintLayerRareData);
+            m_rareData = wrapUnique(new PaintLayerRareData);
         return *m_rareData;
     }
 
     void mergeNeedsPaintPhaseFlagsFrom(const PaintLayer& layer)
     {
         m_needsPaintPhaseDescendantOutlines |= layer.m_needsPaintPhaseDescendantOutlines;
         m_needsPaintPhaseFloat |= layer.m_needsPaintPhaseFloat;
         m_needsPaintPhaseDescendantBlockBackgrounds |= layer.m_needsPaintPhaseDescendantBlockBackgrounds;
     }
 
@@ skipping 79 matching lines @@
     IntSize m_size;
 
     // Cached normal flow values for absolute positioned elements with static left/top values.
     LayoutUnit m_staticInlinePosition;
     LayoutUnit m_staticBlockPosition;
 
     // The first ancestor having a non visible overflow.
     const PaintLayer* m_ancestorOverflowLayer;
 
     AncestorDependentCompositingInputs m_ancestorDependentCompositingInputs;
-    OwnPtr<RareAncestorDependentCompositingInputs> m_rareAncestorDependentCompositingInputs;
+    std::unique_ptr<RareAncestorDependentCompositingInputs> m_rareAncestorDependentCompositingInputs;
 
     Persistent<PaintLayerScrollableArea> m_scrollableArea;
 
-    mutable OwnPtr<ClipRectsCache> m_clipRectsCache;
+    mutable std::unique_ptr<ClipRectsCache> m_clipRectsCache;
 
-    OwnPtr<PaintLayerStackingNode> m_stackingNode;
+    std::unique_ptr<PaintLayerStackingNode> m_stackingNode;
 
     IntSize m_previousScrollOffsetAccumulationForPainting;
     RefPtr<ClipRects> m_previousPaintingClipRects;
     LayoutRect m_previousPaintDirtyRect;
 
-    OwnPtr<PaintLayerRareData> m_rareData;
+    std::unique_ptr<PaintLayerRareData> m_rareData;
 
     DISPLAY_ITEM_CACHE_STATUS_IMPLEMENTATION
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::PaintLayer*);
 void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif // Layer_h