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

cc/scrollbar_layer.cc

 // Copyright 2012 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/scrollbar_layer.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layer_painter.h"
 #include "cc/layer_tree_host.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/texture_update_queue.h"
+#include "ui/gfx/size_conversions.h"
 #include <public/WebRect.h>
 
 using WebKit::WebRect;
 
 namespace cc {
 
 scoped_ptr<LayerImpl> ScrollbarLayer::createLayerImpl()
 {
     return ScrollbarLayerImpl::create(id()).PassAs<LayerImpl>();
 }
@@ skipping 103 matching lines @@
     WebKit::WebScrollbar::ScrollbarPart m_trackPart;
 
     DISALLOW_COPY_AND_ASSIGN(ScrollbarBackgroundPainter);
 };
 
 bool ScrollbarLayer::needsContentsScale() const
 {
     return true;
 }
 
-IntSize ScrollbarLayer::contentBounds() const
+gfx::Size ScrollbarLayer::contentBounds() const
 {
-    return IntSize(lroundf(bounds().width() * contentsScale()), lroundf(bounds().height() * contentsScale()));
+    return gfx::ToRoundedSize(bounds().Scale(contentsScale()));
 }
 
 class ScrollbarThumbPainter : public LayerPainter {
 public:
     static scoped_ptr<ScrollbarThumbPainter> create(WebKit::WebScrollbar* scrollbar, WebKit::WebScrollbarThemePainter painter, WebKit::WebScrollbarThemeGeometry* geometry)
     {
         return make_scoped_ptr(new ScrollbarThumbPainter(scrollbar, painter, geometry));
     }
 
     virtual void paint(SkCanvas* skCanvas, const gfx::Rect& contentRect, gfx::RectF& opaque) OVERRIDE
@@ skipping 50 matching lines @@
         if (!m_foreTrack)
             m_foreTrack = m_foreTrackUpdater->createResource(layerTreeHost()->contentsTextureManager());
     }
 
     if (!m_thumbUpdater)
         m_thumbUpdater = CachingBitmapCanvasLayerUpdater::Create(ScrollbarThumbPainter::create(m_scrollbar.get(), m_painter, m_geometry.get()).PassAs<LayerPainter>());
     if (!m_thumb)
         m_thumb = m_thumbUpdater->createResource(layerTreeHost()->contentsTextureManager());
 }
 
-void ScrollbarLayer::updatePart(CachingBitmapCanvasLayerUpdater* painter, LayerUpdater::Resource* texture, const IntRect& rect, TextureUpdateQueue& queue, RenderingStats& stats)
+void ScrollbarLayer::updatePart(CachingBitmapCanvasLayerUpdater* painter, LayerUpdater::Resource* texture, const gfx::Rect& rect, TextureUpdateQueue& queue, RenderingStats& stats)
 {
     // Skip painting and uploading if there are no invalidations and
     // we already have valid texture data.
     if (texture->texture()->haveBackingTexture()
             && texture->texture()->size() == rect.size()
-            && m_updateRect.isEmpty())
+            && m_updateRect.IsEmpty())
         return;
 
     // We should always have enough memory for UI.
     DCHECK(texture->texture()->canAcquireBackingTexture());
     if (!texture->texture()->canAcquireBackingTexture())
         return;
 
     // Paint and upload the entire part.
     float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
     float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
     gfx::Rect paintedOpaqueRect;
     painter->prepareToUpdate(rect, rect.size(), widthScale, heightScale, paintedOpaqueRect, stats);
     if (!painter->pixelsDidChange() && texture->texture()->haveBackingTexture()) {
         TRACE_EVENT_INSTANT0("cc","ScrollbarLayer::updatePart no texture upload needed");
         return;
     }
 
     gfx::Vector2d destOffset(0, 0);
     texture->update(queue, rect, destOffset, false, stats);
 }
 
 
 void ScrollbarLayer::setTexturePriorities(const PriorityCalculator&)
 {
-    if (contentBounds().isEmpty())
+    if (contentBounds().IsEmpty())
         return;
 
     createUpdaterIfNeeded();
 
     bool drawsToRoot = !renderTarget()->parent();
     if (m_backTrack) {
         m_backTrack->texture()->setDimensions(contentBounds(), m_textureFormat);
         m_backTrack->texture()->setRequestPriority(PriorityCalculator::uiPriority(drawsToRoot));
     }
     if (m_foreTrack) {
         m_foreTrack->texture()->setDimensions(contentBounds(), m_textureFormat);
         m_foreTrack->texture()->setRequestPriority(PriorityCalculator::uiPriority(drawsToRoot));
     }
     if (m_thumb) {
-        IntSize thumbSize = layerRectToContentRect(m_geometry->thumbRect(m_scrollbar.get())).size();
+        gfx::Size thumbSize = layerRectToContentRect(m_geometry->thumbRect(m_scrollbar.get())).size();
         m_thumb->texture()->setDimensions(thumbSize, m_textureFormat);
         m_thumb->texture()->setRequestPriority(PriorityCalculator::uiPriority(drawsToRoot));
     }
 }
 
 void ScrollbarLayer::update(TextureUpdateQueue& queue, const OcclusionTracker*, RenderingStats& stats)
 {
-    if (contentBounds().isEmpty())
+    if (contentBounds().IsEmpty())
         return;
 
     createUpdaterIfNeeded();
 
-    IntPoint scrollbarOrigin(m_scrollbar->location().x, m_scrollbar->location().y);
-    IntRect contentRect = layerRectToContentRect(WebKit::WebRect(scrollbarOrigin.x(), scrollbarOrigin.y(), bounds().width(), bounds().height()));
+    gfx::Point scrollbarOrigin(m_scrollbar->location());
+    gfx::Rect contentRect = layerRectToContentRect(gfx::Rect(scrollbarOrigin, bounds()));
     updatePart(m_backTrackUpdater.get(), m_backTrack.get(), contentRect, queue, stats);
     if (m_foreTrack && m_foreTrackUpdater)
         updatePart(m_foreTrackUpdater.get(), m_foreTrack.get(), contentRect, queue, stats);
 
     // Consider the thumb to be at the origin when painting.
     WebKit::WebRect thumbRect = m_geometry->thumbRect(m_scrollbar.get());
-    IntRect originThumbRect = layerRectToContentRect(WebKit::WebRect(0, 0, thumbRect.width, thumbRect.height));
-    if (!originThumbRect.isEmpty())
+    gfx::Rect originThumbRect = layerRectToContentRect(gfx::Rect(0, 0, thumbRect.width, thumbRect.height));
+    if (!originThumbRect.IsEmpty())
         updatePart(m_thumbUpdater.get(), m_thumb.get(), originThumbRect, queue, stats);
 }
 
 }