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

cc/layer_tree_host.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_tree_host.h"
 
 #include "Region.h"
 #include "base/debug/trace_event.h"
@@ skipping 32 matching lines @@
     , showPlatformLayerTree(false)
     , showPaintRects(false)
     , showPropertyChangedRects(false)
     , showSurfaceDamageRects(false)
     , showScreenSpaceRects(false)
     , showReplicaScreenSpaceRects(false)
     , showOccludingRects(false)
     , renderVSyncEnabled(true)
     , refreshRate(0)
     , maxPartialTextureUpdates(std::numeric_limits<size_t>::max())
-    , defaultTileSize(IntSize(256, 256))
-    , maxUntiledLayerSize(IntSize(512, 512))
-    , minimumOcclusionTrackingSize(IntSize(160, 160))
+    , defaultTileSize(gfx::Size(256, 256))
+    , maxUntiledLayerSize(gfx::Size(512, 512))
+    , minimumOcclusionTrackingSize(gfx::Size(160, 160))
 {
 }
 
 LayerTreeSettings::~LayerTreeSettings()
 {
 }
 
 RendererCapabilities::RendererCapabilities()
     : bestTextureFormat(0)
     , contextHasCachedFrontBuffer(false)
@@ skipping 92 matching lines @@
         return;
     }
 
     // Update m_settings based on capabilities that we got back from the renderer.
     m_settings.acceleratePainting = m_proxy->rendererCapabilities().usingAcceleratedPainting;
 
     // Update m_settings based on partial update capability.
     m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
 
     m_contentsTextureManager = PrioritizedTextureManager::create(0, m_proxy->rendererCapabilities().maxTextureSize, Renderer::ContentPool);
-    m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(IntSize(), GL_RGBA);
+    m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(gfx::Size(), GL_RGBA);
 
     m_rendererInitialized = true;
 
-    m_settings.defaultTileSize = IntSize(min(m_settings.defaultTileSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
-                                         min(m_settings.defaultTileSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
-    m_settings.maxUntiledLayerSize = IntSize(min(m_settings.maxUntiledLayerSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
-                                             min(m_settings.maxUntiledLayerSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
+    m_settings.defaultTileSize = gfx::Size(min(m_settings.defaultTileSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
+                                           min(m_settings.defaultTileSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
+    m_settings.maxUntiledLayerSize = gfx::Size(min(m_settings.maxUntiledLayerSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
+                                               min(m_settings.maxUntiledLayerSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
 }
 
 LayerTreeHost::RecreateResult LayerTreeHost::recreateContext()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::recreateContext");
     DCHECK(m_contextLost);
 
     bool recreated = false;
     if (!m_numTimesRecreateShouldFail)
         recreated = m_proxy->recreateContext();
@@ skipping 228 matching lines @@
     m_rootLayer = rootLayer;
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(this);
 
     if (m_hudLayer)
         m_hudLayer->removeFromParent();
 
     setNeedsCommit();
 }
 
-void LayerTreeHost::setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize)
+void LayerTreeHost::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
     setNeedsCommit();
 }
 
@@ skipping 60 matching lines @@
 }
 
 void LayerTreeHost::updateLayers(ResourceUpdateQueue& queue, size_t memoryAllocationLimitBytes)
 {
     DCHECK(m_rendererInitialized);
     DCHECK(memoryAllocationLimitBytes);
 
     if (!rootLayer())
         return;
 
-    if (layoutViewportSize().isEmpty())
+    if (layoutViewportSize().IsEmpty())
         return;
 
     m_contentsTextureManager->setMaxMemoryLimitBytes(memoryAllocationLimitBytes);
 
     updateLayers(rootLayer(), queue);
 }
 
 static Layer* findFirstScrollableLayer(Layer* layer)
 {
     if (!layer)
@@ skipping 152 matching lines @@
     prioritizeTextures(renderSurfaceLayerList, occlusionTracker.overdrawMetrics());
 
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         occlusionTracker.enterLayer(it);
 
         if (it.representsTargetRenderSurface()) {
             DCHECK(it->renderSurface()->drawOpacity() || it->renderSurface()->drawOpacityIsAnimating());
             needMoreUpdates |= paintMasksForRenderSurface(*it, queue);
         } else if (it.representsItself()) {
-            DCHECK(!it->bounds().isEmpty());
+            DCHECK(!it->bounds().IsEmpty());
             it->update(queue, &occlusionTracker, m_renderingStats);
             needMoreUpdates |= it->needMoreUpdates();
         }
 
         occlusionTracker.leaveLayer(it);
     }
 
     occlusionTracker.overdrawMetrics().recordMetrics(this);
 
     return needMoreUpdates;
@@ skipping 13 matching lines @@
             continue;
         if (layer == rootScrollLayer)
             rootScrollDelta += info.scrolls[i].scrollDelta;
         else
             layer->setScrollPosition(layer->scrollPosition() + info.scrolls[i].scrollDelta);
     }
     if (!rootScrollDelta.isZero() || info.pageScaleDelta != 1)
         m_client->applyScrollAndScale(rootScrollDelta, info.pageScaleDelta);
 }
 
-FloatPoint LayerTreeHost::adjustEventPointForPinchZoom(const FloatPoint& point)
+gfx::PointF LayerTreeHost::adjustEventPointForPinchZoom(const gfx::PointF& point)
     const
 {
     WebKit::WebTransformationMatrix inverseImplTransform = m_implTransform;
     // TODO(wjmaclean) Need to determine why the next two lines are
     // necessary for this to work ... it seems like just inverting
     // m_implTransform should be sufficient.
     DCHECK(inverseImplTransform.m11());
     DCHECK(inverseImplTransform.m22());
     inverseImplTransform.setM41(inverseImplTransform.m41()
         / inverseImplTransform.m11());
     inverseImplTransform.setM42(inverseImplTransform.m42()
         / inverseImplTransform.m22());
     inverseImplTransform = inverseImplTransform.inverse();
     bool wasClipped = false;
-    FloatPoint adjustedPoint = MathUtil::projectPoint(inverseImplTransform, point, wasClipped);
+    gfx::PointF adjustedPoint = MathUtil::projectPoint(inverseImplTransform, point, wasClipped);
     DCHECK(!wasClipped);
 
     return adjustedPoint;
 }
 
 void LayerTreeHost::setImplTransform(const WebKit::WebTransformationMatrix& transform)
 {
     m_implTransform = transform;
 }
 
@@ skipping 95 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace cc