Move rendering/RenderLayer* to layout/

Source/web/LinkHighlight.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 14 matching lines @@
 
 #include "config.h"
 
 #include "web/LinkHighlight.h"
 
 #include "SkMatrix44.h"
 #include "core/dom/Node.h"
 #include "core/dom/NodeRenderingTraversal.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
+#include "core/layout/Layer.h"
+#include "core/layout/LayoutLayerModelObject.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
-#include "core/rendering/RenderLayer.h"
-#include "core/rendering/RenderLayerModelObject.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/ShadowData.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorAnimationCurve.h"
 #include "public/platform/WebCompositorSupport.h"
@@ skipping 52 matching lines @@
 WebLayer* LinkHighlight::clipLayer()
 {
     return m_clipLayer.get();
 }
 
 void LinkHighlight::releaseResources()
 {
     m_node.clear();
 }
 
-void LinkHighlight::attachLinkHighlightToCompositingLayer(const RenderLayerModelObject* paintInvalidationContainer)
+void LinkHighlight::attachLinkHighlightToCompositingLayer(const LayoutLayerModelObject* paintInvalidationContainer)
 {
     GraphicsLayer* newGraphicsLayer = paintInvalidationContainer->layer()->graphicsLayerBacking();
     if (!newGraphicsLayer->drawsContent())
         newGraphicsLayer = paintInvalidationContainer->layer()->graphicsLayerBackingForScrolling();
     if (!newGraphicsLayer)
         return;
 
     m_clipLayer->setTransform(SkMatrix44(SkMatrix44::kIdentity_Constructor));
 
     if (m_currentGraphicsLayer != newGraphicsLayer) {
         if (m_currentGraphicsLayer)
             clearGraphicsLayerLinkHighlightPointer();
 
         m_currentGraphicsLayer = newGraphicsLayer;
         m_currentGraphicsLayer->addLinkHighlight(this);
     }
 }
 
-static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, const RenderLayerModelObject* paintInvalidationContainer, FloatQuad& compositedSpaceQuad)
+static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, const LayoutLayerModelObject* paintInvalidationContainer, FloatQuad& compositedSpaceQuad)
 {
     ASSERT(targetRenderer);
     ASSERT(paintInvalidationContainer);
     for (unsigned i = 0; i < 4; ++i) {
         IntPoint point;
         switch (i) {
         case 0: point = roundedIntPoint(targetSpaceQuad.p1()); break;
         case 1: point = roundedIntPoint(targetSpaceQuad.p2()); break;
         case 2: point = roundedIntPoint(targetSpaceQuad.p3()); break;
         case 3: point = roundedIntPoint(targetSpaceQuad.p4()); break;
         }
 
         // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
         point = targetRenderer->frame()->view()->contentsToWindow(point);
         point = paintInvalidationContainer->frame()->view()->windowToContents(point);
         FloatPoint floatPoint = paintInvalidationContainer->absoluteToLocal(point, UseTransforms);
-        RenderLayer::mapPointToPaintBackingCoordinates(paintInvalidationContainer, floatPoint);
+        Layer::mapPointToPaintBackingCoordinates(paintInvalidationContainer, floatPoint);
 
         switch (i) {
         case 0: compositedSpaceQuad.setP1(floatPoint); break;
         case 1: compositedSpaceQuad.setP2(floatPoint); break;
         case 2: compositedSpaceQuad.setP3(floatPoint); break;
         case 3: compositedSpaceQuad.setP4(floatPoint); break;
         }
     }
 }
 
@@ skipping 21 matching lines @@
     // boxes.
     if (renderer->isRenderInline()) {
         for (Node* child = NodeRenderingTraversal::firstChild(node); child; child = NodeRenderingTraversal::nextSibling(*child))
             computeQuads(*child, outQuads);
     } else {
         // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
         renderer->absoluteQuads(outQuads);
     }
 }
 
-bool LinkHighlight::computeHighlightLayerPathAndPosition(const RenderLayerModelObject* paintInvalidationContainer)
+bool LinkHighlight::computeHighlightLayerPathAndPosition(const LayoutLayerModelObject* paintInvalidationContainer)
 {
     if (!m_node || !m_node->renderer() || !m_currentGraphicsLayer)
         return false;
     ASSERT(paintInvalidationContainer);
 
     // Get quads for node in absolute coordinates.
     Vector<FloatQuad> quads;
     computeQuads(*m_node, quads);
     ASSERT(quads.size());
     Path newPath;
@@ skipping 128 matching lines @@
 void LinkHighlight::updateGeometry()
 {
     // To avoid unnecessary updates (e.g. other entities have requested animations from our WebViewImpl),
     // only proceed if we actually requested an update.
     if (!m_geometryNeedsUpdate)
         return;
 
     m_geometryNeedsUpdate = false;
 
     bool hasRenderer = m_node && m_node->renderer();
-    const RenderLayerModelObject* paintInvalidationContainer = hasRenderer ? m_node->renderer()->containerForPaintInvalidation() : 0;
+    const LayoutLayerModelObject* paintInvalidationContainer = hasRenderer ? m_node->renderer()->containerForPaintInvalidation() : 0;
     if (paintInvalidationContainer)
         attachLinkHighlightToCompositingLayer(paintInvalidationContainer);
     if (paintInvalidationContainer && computeHighlightLayerPathAndPosition(paintInvalidationContainer)) {
         // We only need to invalidate the layer if the highlight size has changed, otherwise
         // we can just re-position the layer without needing to repaint.
         m_contentLayer->layer()->invalidate();
 
         if (m_currentGraphicsLayer)
             m_currentGraphicsLayer->addRepaintRect(FloatRect(layer()->position().x, layer()->position().y, layer()->bounds().width, layer()->bounds().height));
     } else if (!hasRenderer) {
@@ skipping 13 matching lines @@
     // Make sure we update geometry on the next callback from WebViewImpl::layout().
     m_geometryNeedsUpdate = true;
 }
 
 WebLayer* LinkHighlight::layer()
 {
     return clipLayer();
 }
 
 } // namespace blink