Route selection bounds updates through WebLayerTreeView

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 19 matching lines @@
 #include "SkMatrix44.h"
 #include "core/dom/Node.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.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/compositing/CompositedLayerMapping.h"
+#include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "core/rendering/style/ShadowData.h"
 #include "platform/graphics/Color.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAnimationCurve.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebFloatAnimationCurve.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebSize.h"
 #include "public/web/WebKit.h"
@@ skipping 50 matching lines @@
     return m_clipLayer.get();
 }
 
 void LinkHighlight::releaseResources()
 {
     m_node.clear();
 }
 
 RenderLayer* LinkHighlight::computeEnclosingCompositingLayer()
 {
-    if (!m_node || !m_node->renderer())
+    RenderLayer* newRenderLayer;
+    GraphicsLayer* newGraphicsLayer;
+    if (!RenderLayerCompositor::computeEnclosingCompositingLayer(m_node.get(), newRenderLayer, newGraphicsLayer))
         return 0;
 
-    // Find the nearest enclosing composited layer and attach to it. We may need to cross frame boundaries
-    // to find a suitable layer.
-    RenderObject* renderer = m_node->renderer();
-    RenderLayer* renderLayer;
-    do {
-        renderLayer = renderer->enclosingLayer()->enclosingLayerForPaintInvalidation();
-        if (!renderLayer) {
-            renderer = renderer->frame()->ownerRenderer();
-            if (!renderer)
-                return 0;
-        }
-    } while (!renderLayer);
-
-    ASSERT(renderLayer->compositingState() != NotComposited);
-
-    GraphicsLayer* newGraphicsLayer = renderLayer->graphicsLayerBacking();
-    if (!newGraphicsLayer->drawsContent()) {
-        newGraphicsLayer = renderLayer->graphicsLayerBackingForScrolling();
-    }
-
     m_clipLayer->setTransform(SkMatrix44(SkMatrix44::kIdentity_Constructor));
 
     if (m_currentGraphicsLayer != newGraphicsLayer) {
         if (m_currentGraphicsLayer)
             clearGraphicsLayerLinkHighlightPointer();
 
         m_currentGraphicsLayer = newGraphicsLayer;
         m_currentGraphicsLayer->addLinkHighlight(this);
     }
 
-    return renderLayer;
-}
-
-static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, RenderObject* compositedRenderer, FloatQuad& compositedSpaceQuad)
-{
-    ASSERT(targetRenderer);
-    ASSERT(compositedRenderer);
-
-    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;
-        }
-
-        point = targetRenderer->frame()->view()->contentsToWindow(point);
-        point = compositedRenderer->frame()->view()->windowToContents(point);
-        FloatPoint floatPoint = compositedRenderer->absoluteToLocal(point, UseTransforms);
-
-        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;
-        }
-    }
+    return newRenderLayer;
 }
 
 static void addQuadToPath(const FloatQuad& quad, Path& path)
 {
     // FIXME: Make this create rounded quad-paths, just like the axis-aligned case.
     path.moveTo(quad.p1());
     path.addLineTo(quad.p2());
     path.addLineTo(quad.p3());
     path.addLineTo(quad.p4());
     path.closeSubpath();
@@ skipping 35 matching lines @@
     // Adjust for offset between target graphics layer and the node's renderer.
     FloatPoint positionAdjust = IntPoint(m_currentGraphicsLayer->offsetFromRenderer());
 
     Path newPath;
     for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
         FloatQuad absoluteQuad = quads[quadIndex];
         absoluteQuad.move(-positionAdjust.x(), -positionAdjust.y());
 
         // Transform node quads in target absolute coords to local coordinates in the compositor layer.
         FloatQuad transformedQuad;
-        convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), compositingLayer->renderer(), transformedQuad);
+        RenderLayerCompositor::convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), compositingLayer->renderer(), transformedQuad);
 
         // FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
         // we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
         // links: these should ideally be merged into a single rect before creating the path, but that's
         // another CL.
         if (quads.size() == 1 && transformedQuad.isRectilinear()) {
             FloatSize rectRoundingRadii(3, 3);
             newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
         } else
             addQuadToPath(transformedQuad, newPath);
@@ skipping 115 matching lines @@
     // Make sure we update geometry on the next callback from WebViewImpl::layout().
     m_geometryNeedsUpdate = true;
 }
 
 WebLayer* LinkHighlight::layer()
 {
     return clipLayer();
 }
 
 } // namespace WeKit