Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 52 matching lines @@
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/ClipDisplayItem.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/PaintController.h"
 #include "platform/graphics/paint/SkPictureBuilder.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
-#include <memory>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static IntRect clipBox(LayoutBox* layoutObject);
 
 static IntRect contentsRect(const LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
@@ skipping 131 matching lines @@
     updateChildTransformLayer(false);
     updateForegroundLayer(false);
     updateBackgroundLayer(false);
     updateMaskLayer(false);
     updateChildClippingMaskLayer(false);
     updateScrollingLayers(false);
     updateSquashingLayers(false);
     destroyGraphicsLayers();
 }
 
-std::unique_ptr<GraphicsLayer> CompositedLayerMapping::createGraphicsLayer(CompositingReasons reasons, SquashingDisallowedReasons squashingDisallowedReasons)
+PassOwnPtr<GraphicsLayer> CompositedLayerMapping::createGraphicsLayer(CompositingReasons reasons, SquashingDisallowedReasons squashingDisallowedReasons)
 {
-    std::unique_ptr<GraphicsLayer> graphicsLayer = GraphicsLayer::create(this);
+    OwnPtr<GraphicsLayer> graphicsLayer = GraphicsLayer::create(this);
 
     graphicsLayer->setCompositingReasons(reasons);
     graphicsLayer->setSquashingDisallowedReasons(squashingDisallowedReasons);
     if (Node* owningNode = m_owningLayer.layoutObject()->generatingNode())
         graphicsLayer->setOwnerNodeId(DOMNodeIds::idForNode(owningNode));
 
     return graphicsLayer;
 }
 
 void CompositedLayerMapping::createPrimaryGraphicsLayer()
@@ skipping 257 matching lines @@
             layerToApplyChildClippingMask = clippingLayer();
         } else if (hasScrollingLayer()) {
             layerToApplyChildClippingMask = scrollingLayer();
         } else if (isAcceleratedContents(layoutObject)) {
             shouldApplyChildClippingMaskOnContents = true;
         }
     }
 
     updateChildClippingMaskLayer(needsChildClippingMask);
 
-    if (layerToApplyChildClippingMask == m_graphicsLayer.get()) {
+    if (layerToApplyChildClippingMask == m_graphicsLayer) {
         if (m_graphicsLayer->maskLayer() != m_childClippingMaskLayer.get()) {
             m_graphicsLayer->setMaskLayer(m_childClippingMaskLayer.get());
             maskLayerChanged = true;
         }
     } else if (m_graphicsLayer->maskLayer() && m_graphicsLayer->maskLayer() != m_maskLayer.get()) {
         m_graphicsLayer->setMaskLayer(nullptr);
         maskLayerChanged = true;
     }
     if (hasClippingLayer())
         clippingLayer()->setMaskLayer(layerToApplyChildClippingMask == clippingLayer() ? m_childClippingMaskLayer.get() : nullptr);
@@ skipping 807 matching lines @@
     }
 
     return layersChanged;
 }
 
 void CompositedLayerMapping::setBackgroundLayerPaintsFixedRootBackground(bool backgroundLayerPaintsFixedRootBackground)
 {
     m_backgroundLayerPaintsFixedRootBackground = backgroundLayerPaintsFixedRootBackground;
 }
 
-bool CompositedLayerMapping::toggleScrollbarLayerIfNeeded(std::unique_ptr<GraphicsLayer>& layer, bool needsLayer, CompositingReasons reason)
+bool CompositedLayerMapping::toggleScrollbarLayerIfNeeded(OwnPtr<GraphicsLayer>& layer, bool needsLayer, CompositingReasons reason)
 {
     if (needsLayer == !!layer)
         return false;
     layer = needsLayer ? createGraphicsLayer(reason) : nullptr;
 
     if (PaintLayerScrollableArea* scrollableArea = m_owningLayer.getScrollableArea()) {
         if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer)) {
             if (reason == CompositingReasonLayerForHorizontalScrollbar)
                 scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(scrollableArea, HorizontalScrollbar);
             else if (reason == CompositingReasonLayerForVerticalScrollbar)
@@ skipping 899 matching lines @@
 }
 
 static const int kPixelDistanceToRecord = 4000;
 
 IntRect CompositedLayerMapping::recomputeInterestRect(const GraphicsLayer* graphicsLayer) const
 {
     FloatRect graphicsLayerBounds(FloatPoint(), graphicsLayer->size());
 
     IntSize offsetFromAnchorLayoutObject;
     const LayoutBoxModelObject* anchorLayoutObject;
-    if (graphicsLayer == m_squashingLayer.get()) {
+    if (graphicsLayer == m_squashingLayer) {
         // TODO(chrishtr): this is a speculative fix for crbug.com/561306. However, it should never be the case that
         // m_squashingLayer exists yet m_squashedLayers.size() == 0. There must be a bug elsewhere.
         if (m_squashedLayers.size() == 0)
             return IntRect();
         // All squashed layers have the same clip and transform space, so we can use the first squashed layer's
         // layoutObject to map the squashing layer's bounds into viewport space, with offsetFromAnchorLayoutObject
         // to translate squashing layer's bounds into the first squashed layer's space.
         anchorLayoutObject = m_squashedLayers[0].paintLayer->layoutObject();
         offsetFromAnchorLayoutObject = m_squashedLayers[0].offsetFromLayoutObject;
     } else {
-        ASSERT(graphicsLayer == m_graphicsLayer.get() || graphicsLayer == m_scrollingContentsLayer.get());
+        ASSERT(graphicsLayer == m_graphicsLayer || graphicsLayer == m_scrollingContentsLayer);
         anchorLayoutObject = m_owningLayer.layoutObject();
         offsetFromAnchorLayoutObject = graphicsLayer->offsetFromLayoutObject();
         adjustForCompositedScrolling(graphicsLayer, offsetFromAnchorLayoutObject);
     }
 
     // Start with the bounds of the graphics layer in the space of the anchor LayoutObject.
     FloatRect graphicsLayerBoundsInObjectSpace(graphicsLayerBounds);
     graphicsLayerBoundsInObjectSpace.move(offsetFromAnchorLayoutObject);
     // The object space means including writing mode flip.
     if (anchorLayoutObject->isBox())
@@ skipping 64 matching lines @@
 IntRect CompositedLayerMapping::computeInterestRect(const GraphicsLayer* graphicsLayer, const IntRect& previousInterestRect) const
 {
     // Use the previous interest rect if it covers the whole layer.
     IntRect wholeLayerRect = IntRect(IntPoint(), expandedIntSize(graphicsLayer->size()));
     if (!needsRepaint(*graphicsLayer) && previousInterestRect == wholeLayerRect)
         return previousInterestRect;
 
     // Paint the whole layer if "mainFrameClipsContent" is false, meaning that WebPreferences::record_whole_document is true.
     bool shouldPaintWholePage = !m_owningLayer.layoutObject()->document().settings()->mainFrameClipsContent();
     if (shouldPaintWholePage
-        || (graphicsLayer != m_graphicsLayer.get() && graphicsLayer != m_squashingLayer.get() && graphicsLayer != m_squashingLayer.get() && graphicsLayer != m_scrollingContentsLayer.get()))
+        || (graphicsLayer != m_graphicsLayer && graphicsLayer != m_squashingLayer && graphicsLayer != m_squashingLayer && graphicsLayer != m_scrollingContentsLayer))
         return wholeLayerRect;
 
     IntRect newInterestRect = recomputeInterestRect(graphicsLayer);
     if (interestRectChangedEnoughToRepaint(previousInterestRect, newInterestRect, expandedIntSize(graphicsLayer->size())))
         return newInterestRect;
     return previousInterestRect;
 }
 
 LayoutSize CompositedLayerMapping::subpixelAccumulation() const
 {
@@ skipping 38 matching lines @@
         paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
         paintLayerFlags |= PaintLayerPaintingCompositingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintChildClippingMask)
         paintLayerFlags |= PaintLayerPaintingChildClippingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintOverflowContents)
         paintLayerFlags |= PaintLayerPaintingOverflowContents;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintCompositedScroll)
         paintLayerFlags |= PaintLayerPaintingCompositingScrollingPhase;
 
-    if (graphicsLayer == m_backgroundLayer.get())
+    if (graphicsLayer == m_backgroundLayer)
         paintLayerFlags |= (PaintLayerPaintingRootBackgroundOnly | PaintLayerPaintingCompositingForegroundPhase); // Need PaintLayerPaintingCompositingForegroundPhase to walk child layers.
     else if (compositor()->fixedRootBackgroundLayer())
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
 
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
         || graphicsLayer == m_maskLayer.get()
         || graphicsLayer == m_childClippingMaskLayer.get()
         || graphicsLayer == m_scrollingContentsLayer.get()) {
@@ skipping 222 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink