Make the FloatSize constructor from an IntSize explicit.

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 645 matching lines @@
             TRACE_LAYER_INVALIDATION(layers[i].paintLayer, InspectorLayerInvalidationTrackingEvent::SquashingLayerGeometryWasUpdated);
             layersNeedingPaintInvalidation.append(layers[i].paintLayer);
         }
         layers[i].offsetFromLayoutObject = newOffsetFromLayoutObject;
         layers[i].offsetFromLayoutObjectSet = true;
 
         layers[i].paintLayer->setSubpixelAccumulation(subpixelAccumulation);
     }
 
     squashingLayer->setPosition(squashLayerBounds.location());
-    squashingLayer->setSize(squashLayerBounds.size());
+    squashingLayer->setSize(FloatSize(squashLayerBounds.size()));
 
     *offsetFromTransformedAncestor = referenceOffsetFromTransformedAncestor;
     offsetFromTransformedAncestor->move(squashLayerOriginInOwningLayerSpace);
 
     for (size_t i = 0; i < layers.size(); ++i)
         layers[i].localClipRectForSquashedLayer = localClipRectForSquashedLayer(referenceLayer, layers[i], layers);
 }
 
 void CompositedLayerMapping::updateGraphicsLayerGeometry(const PaintLayer* compositingContainer, const PaintLayer* compositingStackingContext, Vector<PaintLayer*>& layersNeedingPaintInvalidation)
 {
@@ skipping 27 matching lines @@
     IntPoint snappedOffsetFromCompositedAncestor;
     computeBoundsOfOwningLayer(compositingContainer, localCompositingBounds, relativeCompositingBounds, offsetFromCompositedAncestor, snappedOffsetFromCompositedAncestor);
 
     IntPoint graphicsLayerParentLocation;
     computeGraphicsLayerParentLocation(compositingContainer, ancestorCompositingBounds, graphicsLayerParentLocation);
 
     // Might update graphicsLayerParentLocation.
     updateAncestorClippingLayerGeometry(compositingContainer, snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateOverflowControlsHostLayerGeometry(compositingStackingContext, compositingContainer);
 
-    FloatSize contentsSize = relativeCompositingBounds.size();
+    FloatSize contentsSize(relativeCompositingBounds.size());
 
     updateMainGraphicsLayerGeometry(relativeCompositingBounds, localCompositingBounds, graphicsLayerParentLocation);
     updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateSquashingLayerGeometry(offsetFromCompositedAncestor, graphicsLayerParentLocation, m_owningLayer, m_squashedLayers, m_squashingLayer.get(), &m_squashingLayerOffsetFromTransformedAncestor, layersNeedingPaintInvalidation);
 
     // If we have a layer that clips children, position it.
     IntRect clippingBox;
     if (m_childContainmentLayer)
         clippingBox = clipBox(toLayoutBox(layoutObject()));
 
@@ skipping 29 matching lines @@
 
     updateCompositingReasons();
 }
 
 void CompositedLayerMapping::updateMainGraphicsLayerGeometry(const IntRect& relativeCompositingBounds, const IntRect& localCompositingBounds, const IntPoint& graphicsLayerParentLocation)
 {
     m_graphicsLayer->setPosition(FloatPoint(relativeCompositingBounds.location() - graphicsLayerParentLocation));
     m_graphicsLayer->setOffsetFromLayoutObject(toIntSize(localCompositingBounds.location()));
 
     FloatSize oldSize = m_graphicsLayer->size();
-    const IntSize& contentsSize = relativeCompositingBounds.size();
+    const FloatSize contentsSize(relativeCompositingBounds.size());
     if (oldSize != contentsSize)
         m_graphicsLayer->setSize(contentsSize);
 
     // m_graphicsLayer is the corresponding GraphicsLayer for this PaintLayer and its non-compositing
     // descendants. So, the visibility flag for m_graphicsLayer should be true if there are any
     // non-compositing visible layers.
     bool contentsVisible = m_owningLayer.hasVisibleContent() || hasVisibleNonCompositingDescendant(&m_owningLayer);
     if (layoutObject()->isVideo()) {
         HTMLVideoElement* videoElement = toHTMLVideoElement(layoutObject()->node());
         if (videoElement->isFullscreen() && videoElement->usesOverlayFullscreenVideo())
@@ skipping 32 matching lines @@
 
 void CompositedLayerMapping::updateAncestorClippingLayerGeometry(const PaintLayer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation)
 {
     if (!compositingContainer || !m_ancestorClippingLayer)
         return;
 
     ClipRectsContext clipRectsContext(compositingContainer, PaintingClipRectsIgnoringOverflowClip, IgnoreOverlayScrollbarSize);
     IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer.clipper().backgroundClipRect(clipRectsContext).rect());
     ASSERT(parentClipRect != LayoutRect::infiniteIntRect());
     m_ancestorClippingLayer->setPosition(FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
-    m_ancestorClippingLayer->setSize(parentClipRect.size());
+    m_ancestorClippingLayer->setSize(FloatSize(parentClipRect.size()));
 
     // backgroundRect is relative to compositingContainer, so subtract snappedOffsetFromCompositedAncestor.X/snappedOffsetFromCompositedAncestor.Y to get back to local coords.
     m_ancestorClippingLayer->setOffsetFromLayoutObject(parentClipRect.location() - snappedOffsetFromCompositedAncestor);
 
     // The primary layer is then parented in, and positioned relative to this clipping layer.
     graphicsLayerParentLocation = parentClipRect.location();
 }
 
 void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(const PaintLayer* compositingStackingContext, const PaintLayer* compositingContainer)
 {
@@ skipping 39 matching lines @@
     FloatPoint clipPositionInLayoutObjectSpace(clippingBox.location() - localCompositingBounds.location() + roundedIntSize(m_owningLayer.subpixelAccumulation()));
 
     // If there are layers between the the child containment layer and
     // m_graphicsLayer (eg, the child transform layer), we must adjust the clip
     // position to get it in the correct space.
     FloatPoint clipPositionInParentSpace = clipPositionInLayoutObjectSpace;
     for (GraphicsLayer* ancestor = m_childContainmentLayer->parent(); ancestor != mainGraphicsLayer(); ancestor = ancestor->parent())
         clipPositionInParentSpace -= toFloatSize(ancestor->position());
 
     m_childContainmentLayer->setPosition(clipPositionInParentSpace);
-    m_childContainmentLayer->setSize(clippingBox.size());
+    m_childContainmentLayer->setSize(FloatSize(clippingBox.size()));
     m_childContainmentLayer->setOffsetFromLayoutObject(toIntSize(clippingBox.location()));
     if (m_childClippingMaskLayer && !m_scrollingLayer && !layoutObject()->style()->clipPath()) {
         m_childClippingMaskLayer->setSize(m_childContainmentLayer->size());
         m_childClippingMaskLayer->setOffsetFromLayoutObject(m_childContainmentLayer->offsetFromLayoutObject());
     }
 }
 
 void CompositedLayerMapping::updateChildTransformLayerGeometry()
 {
     if (!m_childTransformLayer)
         return;
     const IntRect borderBox = toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
-    m_childTransformLayer->setSize(borderBox.size());
+    m_childTransformLayer->setSize(FloatSize(borderBox.size()));
     m_childTransformLayer->setPosition(FloatPoint(contentOffsetInCompositingLayer()));
 }
 
 void CompositedLayerMapping::updateMaskLayerGeometry()
 {
     if (!m_maskLayer)
         return;
 
     if (m_maskLayer->size() != m_graphicsLayer->size()) {
         m_maskLayer->setSize(m_graphicsLayer->size());
@@ skipping 43 matching lines @@
 void CompositedLayerMapping::updateScrollingLayerGeometry(const IntRect& localCompositingBounds)
 {
     if (!m_scrollingLayer)
         return;
 
     ASSERT(m_scrollingContentsLayer);
     LayoutBox* layoutBox = toLayoutBox(layoutObject());
     IntRect overflowClipRect = enclosingIntRect(layoutBox->overflowClipRect(LayoutPoint()));
     DoubleSize adjustedScrollOffset = m_owningLayer.scrollableArea()->adjustedScrollOffset();
     m_scrollingLayer->setPosition(FloatPoint(overflowClipRect.location() - localCompositingBounds.location() + roundedIntSize(m_owningLayer.subpixelAccumulation())));
-    m_scrollingLayer->setSize(overflowClipRect.size());
+    m_scrollingLayer->setSize(FloatSize(overflowClipRect.size()));
 
     IntSize oldScrollingLayerOffset = m_scrollingLayer->offsetFromLayoutObject();
     m_scrollingLayer->setOffsetFromLayoutObject(-toIntSize(overflowClipRect.location()));
 
     if (m_childClippingMaskLayer && !layoutObject()->style()->clipPath()) {
         m_childClippingMaskLayer->setPosition(m_scrollingLayer->position());
         m_childClippingMaskLayer->setSize(m_scrollingLayer->size());
         m_childClippingMaskLayer->setOffsetFromLayoutObject(toIntSize(overflowClipRect.location()));
     }
 
     bool overflowClipRectOffsetChanged = oldScrollingLayerOffset != m_scrollingLayer->offsetFromLayoutObject();
 
     IntSize scrollSize(layoutBox->scrollWidth(), layoutBox->scrollHeight());
     if (scrollSize != m_scrollingContentsLayer->size() || overflowClipRectOffsetChanged)
         m_scrollingContentsLayer->setNeedsDisplay();
 
     DoubleSize scrollingContentsOffset(overflowClipRect.location().x() - adjustedScrollOffset.width(), overflowClipRect.location().y() - adjustedScrollOffset.height());
     // The scroll offset change is compared using floating point so that fractional scroll offset
     // change can be propagated to compositor.
     if (scrollingContentsOffset != m_scrollingContentsLayer->offsetDoubleFromLayoutObject() || scrollSize != m_scrollingContentsLayer->size()) {
         bool coordinatorHandlesOffset = compositor()->scrollingLayerDidChange(&m_owningLayer);
         m_scrollingContentsLayer->setPosition(coordinatorHandlesOffset ? FloatPoint() : FloatPoint(-toFloatSize(adjustedScrollOffset)));
     }
 
-    m_scrollingContentsLayer->setSize(scrollSize);
+    m_scrollingContentsLayer->setSize(FloatSize(scrollSize));
     // FIXME: The paint offset and the scroll offset should really be separate concepts.
     m_scrollingContentsLayer->setOffsetDoubleFromLayoutObject(scrollingContentsOffset, GraphicsLayer::DontSetNeedsDisplay);
 
     if (m_foregroundLayer) {
         if (m_foregroundLayer->size() != m_scrollingContentsLayer->size())
             m_foregroundLayer->setSize(m_scrollingContentsLayer->size());
         m_foregroundLayer->setNeedsDisplay();
         m_foregroundLayer->setOffsetFromLayoutObject(m_scrollingContentsLayer->offsetFromLayoutObject());
     }
 
@@ skipping 49 matching lines @@
 }
 
 void CompositedLayerMapping::updateBackgroundLayerGeometry(const FloatSize& relativeCompositingBoundsSize)
 {
     if (!m_backgroundLayer)
         return;
 
     FloatSize backgroundSize = relativeCompositingBoundsSize;
     if (backgroundLayerPaintsFixedRootBackground()) {
         FrameView* frameView = toLayoutView(layoutObject())->frameView();
-        backgroundSize = frameView->visibleContentRect().size();
+        backgroundSize = FloatSize(frameView->visibleContentRect().size());
     }
     m_backgroundLayer->setPosition(FloatPoint());
     if (backgroundSize != m_backgroundLayer->size()) {
         m_backgroundLayer->setSize(backgroundSize);
         m_backgroundLayer->setNeedsDisplay();
     }
     m_backgroundLayer->setOffsetFromLayoutObject(m_graphicsLayer->offsetFromLayoutObject());
 }
 
 void CompositedLayerMapping::registerScrollingLayers()
@@ skipping 141 matching lines @@
     const bool shouldDrawContent = !blockSelectionGapsBounds.isEmpty();
     m_scrollingBlockSelectionLayer->setDrawsContent(shouldDrawContent);
     if (!shouldDrawContent)
         return;
     // FIXME: Remove the flooredIntSize conversion. crbug.com/414283.
     const IntPoint position = blockSelectionGapsBounds.location() + flooredIntSize(m_owningLayer.scrollableArea()->adjustedScrollOffset());
     if (m_scrollingBlockSelectionLayer->size() == blockSelectionGapsBounds.size() && m_scrollingBlockSelectionLayer->position() == position)
         return;
 
     m_scrollingBlockSelectionLayer->setPosition(position);
-    m_scrollingBlockSelectionLayer->setSize(blockSelectionGapsBounds.size());
+    m_scrollingBlockSelectionLayer->setSize(FloatSize(blockSelectionGapsBounds.size()));
     m_scrollingBlockSelectionLayer->setOffsetFromLayoutObject(toIntSize(blockSelectionGapsBounds.location()), GraphicsLayer::SetNeedsDisplay);
 }
 
 void CompositedLayerMapping::updateDrawsContent()
 {
     bool hasPaintedContent = containsPaintedContent();
     m_graphicsLayer->setDrawsContent(hasPaintedContent);
 
     if (m_scrollingLayer) {
         // m_scrollingLayer never has backing store.
@@ skipping 135 matching lines @@
     return horizontalScrollbarLayerChanged || verticalScrollbarLayerChanged || scrollCornerLayerChanged;
 }
 
 void CompositedLayerMapping::positionOverflowControlsLayers()
 {
     IntSize offsetFromLayoutObject = m_graphicsLayer->offsetFromLayoutObject() - roundedIntSize(m_owningLayer.subpixelAccumulation());
     if (GraphicsLayer* layer = layerForHorizontalScrollbar()) {
         Scrollbar* hBar = m_owningLayer.scrollableArea()->horizontalScrollbar();
         if (hBar) {
             layer->setPosition(hBar->frameRect().location() - offsetFromLayoutObject);
-            layer->setSize(hBar->frameRect().size());
+            layer->setSize(FloatSize(hBar->frameRect().size()));
             if (layer->hasContentsLayer())
                 layer->setContentsRect(IntRect(IntPoint(), hBar->frameRect().size()));
         }
         layer->setDrawsContent(hBar && !layer->hasContentsLayer());
     }
 
     if (GraphicsLayer* layer = layerForVerticalScrollbar()) {
         Scrollbar* vBar = m_owningLayer.scrollableArea()->verticalScrollbar();
         if (vBar) {
             layer->setPosition(vBar->frameRect().location() - offsetFromLayoutObject);
-            layer->setSize(vBar->frameRect().size());
+            layer->setSize(FloatSize(vBar->frameRect().size()));
             if (layer->hasContentsLayer())
                 layer->setContentsRect(IntRect(IntPoint(), vBar->frameRect().size()));
         }
         layer->setDrawsContent(vBar && !layer->hasContentsLayer());
     }
 
     if (GraphicsLayer* layer = layerForScrollCorner()) {
         const IntRect& scrollCornerAndResizer = m_owningLayer.scrollableArea()->scrollCornerAndResizerRect();
         layer->setPosition(FloatPoint(scrollCornerAndResizer.location() - offsetFromLayoutObject));
         layer->setSize(FloatSize(scrollCornerAndResizer.size()));
@@ skipping 1122 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink