cc: Create a cc::ScrollbarThemePainter and an adapter class in compositor bindings.

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 "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/resource_update_queue.h"
 #include "cc/scrollbar_layer_impl.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "ui/gfx/rect_conversions.h"
-#include <public/WebRect.h>
-
-using WebKit::WebRect;
 
 namespace cc {
 
 scoped_ptr<LayerImpl> ScrollbarLayer::createLayerImpl(LayerTreeImpl* treeImpl)
 {
     return ScrollbarLayerImpl::create(treeImpl, id()).PassAs<LayerImpl>();
 }
 
-scoped_refptr<ScrollbarLayer> ScrollbarLayer::create(scoped_ptr<WebKit::WebScrollbar> scrollbar, WebKit::WebScrollbarThemePainter painter, scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry, int scrollLayerId)
+scoped_refptr<ScrollbarLayer> ScrollbarLayer::create(
+    scoped_ptr<WebKit::WebScrollbar> scrollbar,
+    scoped_ptr<ScrollbarThemePainter> painter,
+    scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
+    int scrollLayerId)
 {
-    return make_scoped_refptr(new ScrollbarLayer(scrollbar.Pass(), painter, geometry.Pass(), scrollLayerId));
+    return make_scoped_refptr(new ScrollbarLayer(scrollbar.Pass(), painter.Pass(), geometry.Pass(), scrollLayerId));
 }
 
-ScrollbarLayer::ScrollbarLayer(scoped_ptr<WebKit::WebScrollbar> scrollbar, WebKit::WebScrollbarThemePainter painter, scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry, int scrollLayerId)
+ScrollbarLayer::ScrollbarLayer(
+    scoped_ptr<WebKit::WebScrollbar> scrollbar,
+    scoped_ptr<ScrollbarThemePainter> painter,
+    scoped_ptr<WebKit::WebScrollbarThemeGeometry> geometry,
+    int scrollLayerId)
     : m_scrollbar(scrollbar.Pass())
-    , m_painter(painter)
+    , m_painter(painter.Pass())
     , m_geometry(geometry.Pass())
     , m_scrollLayerId(scrollLayerId)
     , m_textureFormat(GL_INVALID_ENUM)
 {
 }
 
 ScrollbarLayer::~ScrollbarLayer()
 {
 }
 
@@ skipping 67 matching lines @@
         scrollbarLayer->setThumbResourceId(0);
 }
 
 ScrollbarLayer* ScrollbarLayer::toScrollbarLayer()
 {
     return this;
 }
 
 class ScrollbarBackgroundPainter : public LayerPainter {
 public:
-    static scoped_ptr<ScrollbarBackgroundPainter> create(WebKit::WebScrollbar* scrollbar, WebKit::WebScrollbarThemePainter painter, WebKit::WebScrollbarThemeGeometry* geometry, WebKit::WebScrollbar::ScrollbarPart trackPart)
+    static scoped_ptr<ScrollbarBackgroundPainter> create(WebKit::WebScrollbar* scrollbar, ScrollbarThemePainter *painter, WebKit::WebScrollbarThemeGeometry* geometry, WebKit::WebScrollbar::ScrollbarPart trackPart)
     {
         return make_scoped_ptr(new ScrollbarBackgroundPainter(scrollbar, painter, geometry, trackPart));
     }
 
-    virtual void paint(SkCanvas* skCanvas, const gfx::Rect& contentRect, gfx::RectF&) OVERRIDE
+    virtual void paint(SkCanvas* canvas, gfx::Rect contentRect, gfx::RectF&) OVERRIDE
     {
-        WebKit::WebCanvas* canvas = skCanvas;
         // The following is a simplification of ScrollbarThemeComposite::paint.
-        m_painter.paintScrollbarBackground(canvas, contentRect);
+        m_painter->PaintScrollbarBackground(canvas, contentRect);
 
         if (m_geometry->hasButtons(m_scrollbar)) {
-            WebRect backButtonStartPaintRect = m_geometry->backButtonStartRect(m_scrollbar);
-            m_painter.paintBackButtonStart(canvas, backButtonStartPaintRect);
+            gfx::Rect backButtonStartPaintRect = m_geometry->backButtonStartRect(m_scrollbar);
+            m_painter->PaintBackButtonStart(canvas, backButtonStartPaintRect);
 
-            WebRect backButtonEndPaintRect = m_geometry->backButtonEndRect(m_scrollbar);
-            m_painter.paintBackButtonEnd(canvas, backButtonEndPaintRect);
+            gfx::Rect backButtonEndPaintRect = m_geometry->backButtonEndRect(m_scrollbar);
+            m_painter->PaintBackButtonEnd(canvas, backButtonEndPaintRect);
 
-            WebRect forwardButtonStartPaintRect = m_geometry->forwardButtonStartRect(m_scrollbar);
-            m_painter.paintForwardButtonStart(canvas, forwardButtonStartPaintRect);
+            gfx::Rect forwardButtonStartPaintRect = m_geometry->forwardButtonStartRect(m_scrollbar);
+            m_painter->PaintForwardButtonStart(canvas, forwardButtonStartPaintRect);
 
-            WebRect forwardButtonEndPaintRect = m_geometry->forwardButtonEndRect(m_scrollbar);
-            m_painter.paintForwardButtonEnd(canvas, forwardButtonEndPaintRect);
+            gfx::Rect forwardButtonEndPaintRect = m_geometry->forwardButtonEndRect(m_scrollbar);
+            m_painter->PaintForwardButtonEnd(canvas, forwardButtonEndPaintRect);
         }
 
-        WebRect trackPaintRect = m_geometry->trackRect(m_scrollbar);
-        m_painter.paintTrackBackground(canvas, trackPaintRect);
+        gfx::Rect trackPaintRect = m_geometry->trackRect(m_scrollbar);
+        m_painter->PaintTrackBackground(canvas, trackPaintRect);
 
         bool thumbPresent = m_geometry->hasThumb(m_scrollbar);
         if (thumbPresent) {
             if (m_trackPart == WebKit::WebScrollbar::ForwardTrackPart)
-                m_painter.paintForwardTrackPart(canvas, trackPaintRect);
+                m_painter->PaintForwardTrackPart(canvas, trackPaintRect);
             else
-                m_painter.paintBackTrackPart(canvas, trackPaintRect);
+                m_painter->PaintBackTrackPart(canvas, trackPaintRect);
         }
 
-        m_painter.paintTickmarks(canvas, trackPaintRect);
+        m_painter->PaintTickmarks(canvas, trackPaintRect);
     }
 private:
-    ScrollbarBackgroundPainter(WebKit::WebScrollbar* scrollbar, WebKit::WebScrollbarThemePainter painter, WebKit::WebScrollbarThemeGeometry* geometry, WebKit::WebScrollbar::ScrollbarPart trackPart)
+    ScrollbarBackgroundPainter(WebKit::WebScrollbar* scrollbar, ScrollbarThemePainter *painter, WebKit::WebScrollbarThemeGeometry* geometry, WebKit::WebScrollbar::ScrollbarPart trackPart)
         : m_scrollbar(scrollbar)
         , m_painter(painter)
         , m_geometry(geometry)
         , m_trackPart(trackPart)
     {
     }
 
     WebKit::WebScrollbar* m_scrollbar;
-    WebKit::WebScrollbarThemePainter m_painter;
+    ScrollbarThemePainter* m_painter;
     WebKit::WebScrollbarThemeGeometry* m_geometry;
     WebKit::WebScrollbar::ScrollbarPart m_trackPart;
 
     DISALLOW_COPY_AND_ASSIGN(ScrollbarBackgroundPainter);
 };
 
 class ScrollbarThumbPainter : public LayerPainter {
 public:
-    static scoped_ptr<ScrollbarThumbPainter> create(WebKit::WebScrollbar* scrollbar, WebKit::WebScrollbarThemePainter painter, WebKit::WebScrollbarThemeGeometry* geometry)
+    static scoped_ptr<ScrollbarThumbPainter> create(WebKit::WebScrollbar* scrollbar, ScrollbarThemePainter* 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
+    virtual void paint(SkCanvas* canvas, gfx::Rect contentRect, gfx::RectF& opaque) OVERRIDE
     {
-        WebKit::WebCanvas* canvas = skCanvas;
-
         // Consider the thumb to be at the origin when painting.
-        WebRect thumbRect = m_geometry->thumbRect(m_scrollbar);
-        thumbRect.x = 0;
-        thumbRect.y = 0;
-        m_painter.paintThumb(canvas, thumbRect);
+        gfx::Rect thumbRect = m_geometry->thumbRect(m_scrollbar);
+        m_painter->PaintThumb(canvas, gfx::Rect(thumbRect.size()));
     }
 
 private:
-    ScrollbarThumbPainter(WebKit::WebScrollbar* scrollbar, WebKit::WebScrollbarThemePainter painter, WebKit::WebScrollbarThemeGeometry* geometry)
+    ScrollbarThumbPainter(WebKit::WebScrollbar* scrollbar, ScrollbarThemePainter* painter, WebKit::WebScrollbarThemeGeometry* geometry)
         : m_scrollbar(scrollbar)
         , m_painter(painter)
         , m_geometry(geometry)
     {
     }
 
     WebKit::WebScrollbar* m_scrollbar;
-    WebKit::WebScrollbarThemePainter m_painter;
+    ScrollbarThemePainter* m_painter;
     WebKit::WebScrollbarThemeGeometry* m_geometry;
 
     DISALLOW_COPY_AND_ASSIGN(ScrollbarThumbPainter);
 };
 
 void ScrollbarLayer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (!host || host != layerTreeHost()) {
         m_backTrackUpdater = NULL;
         m_backTrack.reset();
         m_thumbUpdater = NULL;
         m_thumb.reset();
     }
 
     ContentsScalingLayer::setLayerTreeHost(host);
 }
 
 void ScrollbarLayer::createUpdaterIfNeeded()
 {
     m_textureFormat = layerTreeHost()->rendererCapabilities().bestTextureFormat;
 
     if (!m_backTrackUpdater)
-        m_backTrackUpdater = CachingBitmapContentLayerUpdater::Create(ScrollbarBackgroundPainter::create(m_scrollbar.get(), m_painter, m_geometry.get(), WebKit::WebScrollbar::BackTrackPart).PassAs<LayerPainter>());
+        m_backTrackUpdater = CachingBitmapContentLayerUpdater::Create(ScrollbarBackgroundPainter::create(m_scrollbar.get(), m_painter.get(), m_geometry.get(), WebKit::WebScrollbar::BackTrackPart).PassAs<LayerPainter>());
     if (!m_backTrack)
         m_backTrack = m_backTrackUpdater->createResource(layerTreeHost()->contentsTextureManager());
 
     // Only create two-part track if we think the two parts could be different in appearance.
     if (m_scrollbar->isCustomScrollbar()) {
         if (!m_foreTrackUpdater)
-            m_foreTrackUpdater = CachingBitmapContentLayerUpdater::Create(ScrollbarBackgroundPainter::create(m_scrollbar.get(), m_painter, m_geometry.get(), WebKit::WebScrollbar::ForwardTrackPart).PassAs<LayerPainter>());
+            m_foreTrackUpdater = CachingBitmapContentLayerUpdater::Create(ScrollbarBackgroundPainter::create(m_scrollbar.get(), m_painter.get(), m_geometry.get(), WebKit::WebScrollbar::ForwardTrackPart).PassAs<LayerPainter>());
         if (!m_foreTrack)
             m_foreTrack = m_foreTrackUpdater->createResource(layerTreeHost()->contentsTextureManager());
     }
 
     if (!m_thumbUpdater)
-        m_thumbUpdater = CachingBitmapContentLayerUpdater::Create(ScrollbarThumbPainter::create(m_scrollbar.get(), m_painter, m_geometry.get()).PassAs<LayerPainter>());
+        m_thumbUpdater = CachingBitmapContentLayerUpdater::Create(ScrollbarThumbPainter::create(m_scrollbar.get(), m_painter.get(), m_geometry.get()).PassAs<LayerPainter>());
     if (!m_thumb)
         m_thumb = m_thumbUpdater->createResource(layerTreeHost()->contentsTextureManager());
 }
 
-void ScrollbarLayer::updatePart(CachingBitmapContentLayerUpdater* painter, LayerUpdater::Resource* texture, const gfx::Rect& rect, ResourceUpdateQueue& queue, RenderingStats& stats)
+void ScrollbarLayer::updatePart(CachingBitmapContentLayerUpdater* painter, LayerUpdater::Resource* resource, const gfx::Rect& rect, ResourceUpdateQueue& 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())
+    if (resource->texture()->haveBackingTexture() &&
+        resource->texture()->size() == rect.size() &&
+        m_updateRect.IsEmpty())
         return;
 
     // We should always have enough memory for UI.
-    DCHECK(texture->texture()->canAcquireBackingTexture());
-    if (!texture->texture()->canAcquireBackingTexture())
+    DCHECK(resource->texture()->canAcquireBackingTexture());
+    if (!resource->texture()->canAcquireBackingTexture())
         return;
 
     // Paint and upload the entire part.
     gfx::Rect paintedOpaqueRect;
     painter->prepareToUpdate(rect, rect.size(), contentsScaleX(), contentsScaleY(), paintedOpaqueRect, stats);
-    if (!painter->pixelsDidChange() && texture->texture()->haveBackingTexture()) {
+    if (!painter->pixelsDidChange() && resource->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);
+    resource->update(queue, rect, destOffset, false, stats);
 }
 
 gfx::Rect ScrollbarLayer::scrollbarLayerRectToContentRect(const gfx::Rect& layerRect) const
 {
     // Don't intersect with the bounds as in layerRectToContentRect() because
     // layerRect here might be in coordinates of the containing layer.
     gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
     return gfx::ToEnclosingRect(contentRect);
 }
 
@@ skipping 35 matching lines @@
         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());
     gfx::Rect originThumbRect = scrollbarLayerRectToContentRect(gfx::Rect(0, 0, thumbRect.width, thumbRect.height));
     if (!originThumbRect.IsEmpty())
         updatePart(m_thumbUpdater.get(), m_thumb.get(), originThumbRect, queue, stats);
 }
 
 }  // namespace cc