cc: Use gfx:: Geometry types for positions, bounds, and related things.

cc/layer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "cc/layer.h"
 
 #include "cc/active_animation.h"
 #include "cc/animation_events.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host.h"
 #include "cc/settings.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
+#include "ui/gfx/rect_conversions.h"
 #include <public/WebAnimationDelegate.h>
 #include <public/WebLayerScrollClient.h>
 #include <public/WebSize.h>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 static int s_nextLayerId = 1;
@@ skipping 87 matching lines @@
     if (host && m_layerAnimationController->hasActiveAnimation())
         host->didAddAnimation();
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
-IntRect Layer::layerRectToContentRect(const WebKit::WebRect& layerRect)
+gfx::Rect Layer::layerRectToContentRect(const gfx::Rect& layerRect)
 {
     float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
     float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
-    FloatRect contentRect(layerRect.x, layerRect.y, layerRect.width, layerRect.height);
-    contentRect.scale(widthScale, heightScale);
-    return enclosingIntRect(contentRect);
+    gfx::RectF contentRect = gfx::ScaleRect(layerRect, widthScale, heightScale);
+    return gfx::ToEnclosingRect(contentRect);
 }
 
 void Layer::setParent(Layer* layer)
 {
     DCHECK(!layer || !layer->hasAncestor(this));
     m_parent = layer;
     setLayerTreeHost(m_parent ? m_parent->layerTreeHost() : 0);
 
     forceAutomaticRasterScaleToBeRecomputed();
 }
@@ skipping 68 matching lines @@
 
 int Layer::indexOfChild(const Layer* reference)
 {
     for (size_t i = 0; i < m_children.size(); i++) {
         if (m_children[i] == reference)
             return i;
     }
     return -1;
 }
 
-void Layer::setBounds(const IntSize& size)
+void Layer::setBounds(const gfx::Size& size)
 {
     if (bounds() == size)
         return;
 
-    bool firstResize = bounds().isEmpty() && !size.isEmpty();
+    bool firstResize = bounds().IsEmpty() && !size.IsEmpty();
 
     m_bounds = size;
 
     if (firstResize)
         setNeedsDisplay();
     else
         setNeedsCommit();
 }
 
 Layer* Layer::rootLayer()
@@ skipping 17 matching lines @@
 {
     if (children == m_children)
         return;
 
     removeAllChildren();
     size_t listSize = children.size();
     for (size_t i = 0; i < listSize; i++)
         addChild(children[i]);
 }
 
-void Layer::setAnchorPoint(const FloatPoint& anchorPoint)
+void Layer::setAnchorPoint(const gfx::PointF& anchorPoint)
 {
     if (m_anchorPoint == anchorPoint)
         return;
     m_anchorPoint = anchorPoint;
     setNeedsCommit();
 }
 
 void Layer::setAnchorPointZ(float anchorPointZ)
 {
     if (m_anchorPointZ == anchorPointZ)
         return;
     m_anchorPointZ = anchorPointZ;
     setNeedsCommit();
 }
 
 void Layer::setBackgroundColor(SkColor backgroundColor)
 {
     if (m_backgroundColor == backgroundColor)
         return;
     m_backgroundColor = backgroundColor;
     setNeedsCommit();
 }
 
-IntSize Layer::contentBounds() const
+gfx::Size Layer::contentBounds() const
 {
     return bounds();
 }
 
 void Layer::setMasksToBounds(bool masksToBounds)
 {
     if (m_masksToBounds == masksToBounds)
         return;
     m_masksToBounds = masksToBounds;
     setNeedsCommit();
@@ skipping 76 matching lines @@
 }
 
 void Layer::setContentsOpaque(bool opaque)
 {
     if (m_contentsOpaque == opaque)
         return;
     m_contentsOpaque = opaque;
     setNeedsDisplay();
 }
 
-void Layer::setPosition(const FloatPoint& position)
+void Layer::setPosition(const gfx::PointF& position)
 {
     if (m_position == position)
         return;
     m_position = position;
     setNeedsCommit();
 }
 
 void Layer::setSublayerTransform(const WebTransformationMatrix& sublayerTransform)
 {
     if (m_sublayerTransform == sublayerTransform)
@@ skipping 105 matching lines @@
 
     m_isDrawable = isDrawable;
     setNeedsCommit();
 }
 
 Layer* Layer::parent() const
 {
     return m_parent;
 }
 
-void Layer::setNeedsDisplayRect(const FloatRect& dirtyRect)
+void Layer::setNeedsDisplayRect(const gfx::RectF& dirtyRect)
 {
-    m_updateRect.unite(dirtyRect);
+    m_updateRect.Union(dirtyRect);
 
     // Simply mark the contents as dirty. For non-root layers, the call to
     // setNeedsCommit will schedule a fresh compositing pass.
     // For the root layer, setNeedsCommit has no effect.
-    if (!dirtyRect.isEmpty())
+    if (!dirtyRect.IsEmpty())
         m_needsDisplay = true;
 
     setNeedsCommit();
 }
 
 bool Layer::descendantIsFixedToContainerLayer() const
 {
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i]->fixedToContainerLayer() || m_children[i]->descendantIsFixedToContainerLayer())
             return true;
@@ skipping 61 matching lines @@
     layer->setUseParentBackfaceVisibility(m_useParentBackfaceVisibility);
     layer->setScrollPosition(m_scrollPosition);
     layer->setMaxScrollPosition(m_maxScrollPosition);
     layer->setSublayerTransform(m_sublayerTransform);
     if (!transformIsAnimating())
         layer->setTransform(m_transform);
 
     // If the main thread commits multiple times before the impl thread actually draws, then damage tracking
     // will become incorrect if we simply clobber the updateRect here. The LayerImpl's updateRect needs to
     // accumulate (i.e. union) any update changes that have occurred on the main thread.
-    m_updateRect.uniteIfNonZero(layer->updateRect());
+    m_updateRect.Union(layer->updateRect());
     layer->setUpdateRect(m_updateRect);
 
     layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
     layer->setSentScrollDelta(IntSize());
 
     layer->setStackingOrderChanged(m_stackingOrderChanged);
 
     if (maskLayer())
         maskLayer()->pushPropertiesTo(layer->maskLayer());
     if (replicaLayer())
         replicaLayer()->pushPropertiesTo(layer->replicaLayer());
 
     m_layerAnimationController->pushAnimationUpdatesTo(layer->layerAnimationController());
 
     // Reset any state that should be cleared for the next update.
     m_stackingOrderChanged = false;
-    m_updateRect = FloatRect();
+    m_updateRect = gfx::RectF();
 }
 
 scoped_ptr<LayerImpl> Layer::createLayerImpl()
 {
     return LayerImpl::create(m_layerId);
 }
 
 bool Layer::drawsContent() const
 {
     return m_isDrawable;
@@ skipping 200 matching lines @@
 
 void Layer::notifyAnimationFinished(double wallClockTime)
 {
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationFinished(wallClockTime);
 }
 
 Region Layer::visibleContentOpaqueRegion() const
 {
     if (contentsOpaque())
-        return visibleContentRect();
+        return cc::IntRect(visibleContentRect());
     return Region();
 }
 
 ScrollbarLayer* Layer::toScrollbarLayer()
 {
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }