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

cc/layer_impl.cc

 // Copyright 2011 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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/layer_sorter.h"
 #include "cc/math_util.h"
 #include "cc/proxy.h"
 #include "cc/quad_sink.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/settings.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
+#include "ui/gfx/point_conversions.h"
+#include "ui/gfx/rect_conversions.h"
 
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 LayerImpl::LayerImpl(int id)
     : m_parent(0)
     , m_maskLayerId(-1)
     , m_replicaLayerId(-1)
     , m_layerId(id)
@@ skipping 116 matching lines @@
     DCHECK(m_betweenWillDrawAndDidDraw);
     m_betweenWillDrawAndDidDraw = false;
 #endif
 }
 
 void LayerImpl::appendDebugBorderQuad(QuadSink& quadList, const SharedQuadState* sharedQuadState, AppendQuadsData& appendQuadsData) const
 {
     if (!hasDebugBorders())
         return;
 
-    IntRect contentRect(IntPoint(), contentBounds());
+    gfx::Rect contentRect(gfx::Point(), contentBounds());
     quadList.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect, debugBorderColor(), debugBorderWidth()).PassAs<DrawQuad>(), appendQuadsData);
 }
 
 bool LayerImpl::hasContributingDelegatedRenderPasses() const
 {
     return false;
 }
 
 RenderPass::Id LayerImpl::firstContributingRenderPassId() const
 {
@@ skipping 37 matching lines @@
         return InputHandlerClient::ScrollOnMainThread;
     }
 
     if (!screenSpaceTransform().isInvertible()) {
         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored nonInvertibleTransform");
         return InputHandlerClient::ScrollIgnored;
     }
 
     if (!nonFastScrollableRegion().isEmpty()) {
         bool clipped = false;
-        FloatPoint hitTestPointInLocalSpace = MathUtil::projectPoint(screenSpaceTransform().inverse(), FloatPoint(screenSpacePoint), clipped);
-        if (!clipped && nonFastScrollableRegion().contains(flooredIntPoint(hitTestPointInLocalSpace))) {
+        gfx::PointF hitTestPointInLocalSpace = MathUtil::projectPoint(screenSpaceTransform().inverse(), FloatPoint(screenSpacePoint), clipped);
+        if (!clipped && nonFastScrollableRegion().contains(cc::IntPoint(gfx::ToFlooredPoint(hitTestPointInLocalSpace)))) {
             TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed nonFastScrollableRegion");
             return InputHandlerClient::ScrollOnMainThread;
         }
     }
 
     if (type == InputHandlerClient::Wheel && haveWheelEventHandlers()) {
         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed wheelEventHandlers");
         return InputHandlerClient::ScrollOnMainThread;
     }
 
     if (!scrollable()) {
         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
         return InputHandlerClient::ScrollIgnored;
     }
 
     return InputHandlerClient::ScrollStarted;
 }
 
 bool LayerImpl::drawCheckerboardForMissingTiles() const
 {
     return m_drawCheckerboardForMissingTiles && !Settings::backgroundColorInsteadOfCheckerboard();
 }
 
-IntRect LayerImpl::layerRectToContentRect(const FloatRect& layerRect) const
+gfx::Rect LayerImpl::layerRectToContentRect(const gfx::RectF& layerRect) const
 {
-    FloatRect contentRect(layerRect);
-    contentRect.scale(contentsScaleX(), contentsScaleY());
-    IntRect intContentRect = enclosingIntRect(contentRect);
+    gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
     // Intersect with content rect to avoid the extra pixel because for some
     // values x and y, ceil((x / y) * y) may be x + 1.
-    intContentRect.intersect(IntRect(IntPoint(), contentBounds()));
-    return intContentRect;
+    contentRect.Intersect(gfx::Rect(gfx::Point(), contentBounds()));
+    return gfx::ToEnclosingRect(contentRect);
 }
 
 std::string LayerImpl::indentString(int indent)
 {
     std::string str;
     for (int i = 0; i != indent; ++i)
         str.append("  ");
     return str;
 }
 
@@ skipping 96 matching lines @@
 const char* LayerImpl::layerTypeAsString() const
 {
     return "Layer";
 }
 
 void LayerImpl::resetAllChangeTrackingForSubtree()
 {
     m_layerPropertyChanged = false;
     m_layerSurfacePropertyChanged = false;
 
-    m_updateRect = FloatRect();
+    m_updateRect = gfx::RectF();
 
     if (m_renderSurface)
         m_renderSurface->resetPropertyChangedFlag();
 
     if (m_maskLayer)
         m_maskLayer->resetAllChangeTrackingForSubtree();
 
     if (m_replicaLayer)
         m_replicaLayer->resetAllChangeTrackingForSubtree(); // also resets the replica mask, if it exists.
 
@@ skipping 24 matching lines @@
 const WebKit::WebTransformationMatrix& LayerImpl::transform() const
 {
      return m_transform;
 }
 
 void LayerImpl::setTransformFromAnimation(const WebTransformationMatrix& transform)
 {
     setTransform(transform);
 }
 
-void LayerImpl::setBounds(const IntSize& bounds)
+void LayerImpl::setBounds(const gfx::Size& bounds)
 {
     if (m_bounds == bounds)
         return;
 
     m_bounds = bounds;
 
     if (masksToBounds())
         noteLayerPropertyChangedForSubtree();
     else
         m_layerPropertyChanged = true;
@@ skipping 25 matching lines @@
 
 void LayerImpl::setDrawsContent(bool drawsContent)
 {
     if (m_drawsContent == drawsContent)
         return;
 
     m_drawsContent = drawsContent;
     m_layerPropertyChanged = true;
 }
 
-void LayerImpl::setAnchorPoint(const FloatPoint& anchorPoint)
+void LayerImpl::setAnchorPoint(const gfx::PointF& anchorPoint)
 {
     if (m_anchorPoint == anchorPoint)
         return;
 
     m_anchorPoint = anchorPoint;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setAnchorPointZ(float anchorPointZ)
 {
@@ skipping 67 matching lines @@
 
     m_opacity = opacity;
     m_layerSurfacePropertyChanged = true;
 }
 
 bool LayerImpl::opacityIsAnimating() const
 {
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Opacity);
 }
 
-void LayerImpl::setPosition(const FloatPoint& position)
+void LayerImpl::setPosition(const gfx::PointF& position)
 {
     if (m_position == position)
         return;
 
     m_position = position;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setPreserves3D(bool preserves3D)
 {
@@ skipping 44 matching lines @@
 
     m_debugBorderWidth = debugBorderWidth;
     m_layerPropertyChanged = true;
 }
 
 bool LayerImpl::hasDebugBorders() const
 {
     return SkColorGetA(m_debugBorderColor) && debugBorderWidth() > 0;
 }
 
-void LayerImpl::setContentBounds(const IntSize& contentBounds)
+void LayerImpl::setContentBounds(const gfx::Size& contentBounds)
 {
     if (m_contentBounds == contentBounds)
         return;
 
     m_contentBounds = contentBounds;
     m_layerPropertyChanged = true;
 }
 
 void LayerImpl::setContentsScale(float contentsScaleX, float contentsScaleY)
 {
@@ skipping 37 matching lines @@
     if (m_doubleSided == doubleSided)
         return;
 
     m_doubleSided = doubleSided;
     noteLayerPropertyChangedForSubtree();
 }
 
 Region LayerImpl::visibleContentOpaqueRegion() const
 {
     if (contentsOpaque())
-        return visibleContentRect();
+        return cc::IntRect(visibleContentRect());
     return Region();
 }
 
 void LayerImpl::didLoseContext()
 {
 }
 
 void LayerImpl::setMaxScrollPosition(const IntSize& maxScrollPosition)
 {
     m_maxScrollPosition = maxScrollPosition;
@@ skipping 23 matching lines @@
 
 void LayerImpl::setVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 {
     if (!m_scrollbarAnimationController)
         m_scrollbarAnimationController = ScrollbarAnimationController::create(this);
     m_scrollbarAnimationController->setVerticalScrollbarLayer(scrollbarLayer);
     m_scrollbarAnimationController->updateScrollOffset(this);
 }
 
 }