Don't depend on WEBKIT_IMPLEMENTATION guarded geometry conversion c'tors

webkit/compositor_bindings/WebLayerImpl.cpp

 // 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 "WebLayerImpl.h"
 
 #include "CCActiveAnimation.h"
 #include "LayerChromium.h"
 #include "SkMatrix44.h"
 #include "WebAnimationImpl.h"
 #ifdef LOG
 #undef LOG
 #endif
 #include "base/string_util.h"
+#include "webcore_convert.h"
 #include <public/WebFloatPoint.h>
 #include <public/WebFloatRect.h>
 #include <public/WebSize.h>
 #include <public/WebTransformationMatrix.h>
 
 using WebCore::CCActiveAnimation;
 using WebCore::LayerChromium;
 
 namespace WebKit {
 
@@ skipping 24 matching lines @@
     skMatrix.set(1, 2, SkDoubleToMScalar(matrix.m32()));
     skMatrix.set(2, 2, SkDoubleToMScalar(matrix.m33()));
     skMatrix.set(3, 2, SkDoubleToMScalar(matrix.m34()));
     skMatrix.set(0, 3, SkDoubleToMScalar(matrix.m41()));
     skMatrix.set(1, 3, SkDoubleToMScalar(matrix.m42()));
     skMatrix.set(2, 3, SkDoubleToMScalar(matrix.m43()));
     skMatrix.set(3, 3, SkDoubleToMScalar(matrix.m44()));
     return skMatrix;
 }
 
-} // anonymous namespace
-
+}
 
 WebLayer* WebLayer::create()
 {
     return new WebLayerImpl();
 }
 
 WebLayerImpl::WebLayerImpl()
     : m_layer(LayerChromium::create())
 {
 }
@@ skipping 10 matching lines @@
     m_layer->setLayerAnimationDelegate(0);
 }
 
 int WebLayerImpl::id() const
 {
     return m_layer->id();
 }
 
 void WebLayerImpl::invalidateRect(const WebFloatRect& rect)
 {
-    m_layer->setNeedsDisplayRect(rect);
+    m_layer->setNeedsDisplayRect(convert(rect));
 }
 
 void WebLayerImpl::invalidate()
 {
     m_layer->setNeedsDisplay();
 }
 
 void WebLayerImpl::addChild(WebLayer* child)
 {
     m_layer->addChild(static_cast<WebLayerImpl*>(child)->layer());
@@ skipping 14 matching lines @@
     m_layer->removeFromParent();
 }
 
 void WebLayerImpl::removeAllChildren()
 {
     m_layer->removeAllChildren();
 }
 
 void WebLayerImpl::setAnchorPoint(const WebFloatPoint& anchorPoint)
 {
-    m_layer->setAnchorPoint(anchorPoint);
+    m_layer->setAnchorPoint(convert(anchorPoint));
 }
 
 WebFloatPoint WebLayerImpl::anchorPoint() const
 {
-    return WebFloatPoint(m_layer->anchorPoint());
+    return WebFloatPoint(m_layer->anchorPoint().x(), m_layer->anchorPoint().y());
 }
 
 void WebLayerImpl::setAnchorPointZ(float anchorPointZ)
 {
     m_layer->setAnchorPointZ(anchorPointZ);
 }
 
 float WebLayerImpl::anchorPointZ() const
 {
     return m_layer->anchorPointZ();
 }
 
 void WebLayerImpl::setBounds(const WebSize& size)
 {
-    m_layer->setBounds(size);
+    m_layer->setBounds(convert(size));
 }
 
 WebSize WebLayerImpl::bounds() const
 {
-    return WebSize(m_layer->bounds());
+    return convert(m_layer->bounds());
 }
 
 void WebLayerImpl::setMasksToBounds(bool masksToBounds)
 {
     m_layer->setMasksToBounds(masksToBounds);
 }
 
 bool WebLayerImpl::masksToBounds() const
 {
     return m_layer->masksToBounds();
@@ skipping 24 matching lines @@
     m_layer->setOpaque(opaque);
 }
 
 bool WebLayerImpl::opaque() const
 {
     return m_layer->opaque();
 }
 
 void WebLayerImpl::setPosition(const WebFloatPoint& position)
 {
-    m_layer->setPosition(position);
+    m_layer->setPosition(convert(position));
 }
 
 WebFloatPoint WebLayerImpl::position() const
 {
-    return WebFloatPoint(m_layer->position());
+    return WebFloatPoint(m_layer->position().x(), m_layer->position().y());
 }
 
 void WebLayerImpl::setSublayerTransform(const SkMatrix44& matrix)
 {
     m_layer->setSublayerTransform(transformationMatrixFromSkMatrix44(matrix));
 }
 
 void WebLayerImpl::setSublayerTransform(const WebTransformationMatrix& matrix)
 {
     m_layer->setSublayerTransform(matrix);
@@ skipping 115 matching lines @@
     static_cast<WebLayerImpl*>(other)->m_layer->setLayerAnimationController(m_layer->releaseLayerAnimationController());
 }
 
 void WebLayerImpl::setForceRenderSurface(bool forceRenderSurface)
 {
     m_layer->setForceRenderSurface(forceRenderSurface);
 }
 
 void WebLayerImpl::setScrollPosition(WebPoint position)
 {
-    m_layer->setScrollPosition(position);
+    m_layer->setScrollPosition(convert(position));
 }
 
 WebPoint WebLayerImpl::scrollPosition() const
 {
-    return m_layer->scrollPosition();
+    return WebPoint(m_layer->scrollPosition().x(), m_layer->scrollPosition().y());
 }
 
 void WebLayerImpl::setMaxScrollPosition(WebSize maxScrollPosition)
 {
-    m_layer->setMaxScrollPosition(maxScrollPosition);
+    m_layer->setMaxScrollPosition(convert(maxScrollPosition));
 }
 
 void WebLayerImpl::setScrollable(bool scrollable)
 {
     m_layer->setScrollable(scrollable);
 }
 
 void WebLayerImpl::setHaveWheelEventHandlers(bool haveWheelEventHandlers)
 {
     m_layer->setHaveWheelEventHandlers(haveWheelEventHandlers);
 }
 
 void WebLayerImpl::setShouldScrollOnMainThread(bool shouldScrollOnMainThread)
 {
     m_layer->setShouldScrollOnMainThread(shouldScrollOnMainThread);
 }
 
 void WebLayerImpl::setNonFastScrollableRegion(const WebVector<WebRect>& rects)
 {
     WebCore::Region region;
     for (size_t i = 0; i < rects.size(); ++i) {
-        WebCore::IntRect rect = rects[i];
+        WebCore::IntRect rect = convert(rects[i]);
         region.unite(rect);
     }
     m_layer->setNonFastScrollableRegion(region);
 
 }
 
 void WebLayerImpl::setIsContainerForFixedPositionLayers(bool enable)
 {
     m_layer->setIsContainerForFixedPositionLayers(enable);
 }
 
 void WebLayerImpl::setFixedToContainerLayer(bool enable)
 {
     m_layer->setFixedToContainerLayer(enable);
 }
 
 void WebLayerImpl::setScrollClient(WebLayerScrollClient* scrollClient)
 {
     m_layer->setLayerScrollClient(scrollClient);
 }
 
 LayerChromium* WebLayerImpl::layer() const
 {
     return m_layer.get();
 }
 
 } // namespace WebKit