Route selection bounds updates through WebLayerTreeView

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 348 matching lines @@
 
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled())
             applyOverlayFullscreenVideoAdjustment();
     }
 
     if (m_needsUpdateFixedBackground) {
         rootFixedBackgroundsChanged();
         m_needsUpdateFixedBackground = false;
     }
 
+
+

[abarth-chromium, 2014/06/13 21:38:14]

This change is spurious.

     // The scrolling coordinator may realize that it needs updating while compositing was being updated in this function.
     needsToUpdateScrollingCoordinator |= scrollingCoordinator() && scrollingCoordinator()->needsToUpdateAfterCompositingChange();
     if (needsToUpdateScrollingCoordinator && m_renderView.frame()->isMainFrame() && scrollingCoordinator() && inCompositingMode())
         scrollingCoordinator()->updateAfterCompositingChange();
 
     for (unsigned i = 0; i < layersNeedingRepaint.size(); i++) {
         RenderLayer* layer = layersNeedingRepaint[i];
         layer->repainter().computeRepaintRectsIncludingNonCompositingDescendants();
 
         repaintOnCompositingChange(layer);
@@ skipping 281 matching lines @@
     CompositedLayerMappingPtr compositedLayerMapping = layer->compositedLayerMapping();
     GraphicsLayer* hostingLayer = compositedLayerMapping->parentForSublayers();
     GraphicsLayer* rootLayer = innerCompositor->rootGraphicsLayer();
     if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != rootLayer) {
         hostingLayer->removeAllChildren();
         hostingLayer->addChild(rootLayer);
     }
     return true;
 }
 
+bool RenderLayerCompositor::computeEnclosingCompositingLayer(Node* node, RenderLayer*& renderLayer, GraphicsLayer*& graphicsLayer)
+{
+    if (!node || !node->renderer())
+        return false;
+
+    // Find the nearest enclosing composited layer and attach to it. We may need to cross frame boundaries
+    // to find a suitable layer.
+    RenderObject* renderer = node->renderer();
+    RenderLayer* currentRenderLayer;
+    do {
+        currentRenderLayer = renderer->enclosingLayer()->enclosingCompositingLayerForRepaint();
+        if (!currentRenderLayer) {
+            renderer = renderer->frame()->ownerRenderer();
+            if (!renderer)
+                return false;
+        }
+    } while (!currentRenderLayer);

[abarth-chromium, 2014/06/13 21:38:14]

We shouldn't need to do this sort of search.  Instead, this computation should
be integrated with one of the existing tree walks.

+
+    renderLayer = currentRenderLayer;
+    CompositedLayerMappingPtr compositedLayerMapping = renderLayer->compositingState() == PaintsIntoGroupedBacking ? renderLayer->groupedMapping() : renderLayer->compositedLayerMapping();
+    graphicsLayer = renderLayer->compositingState() == PaintsIntoGroupedBacking ? compositedLayerMapping->squashingLayer() : compositedLayerMapping->mainGraphicsLayer();
+
+    if (!graphicsLayer->drawsContent()) {
+        if (renderLayer->scrollableArea() && renderLayer->scrollableArea()->usesCompositedScrolling()) {
+            ASSERT(renderLayer->hasCompositedLayerMapping() && renderLayer->compositedLayerMapping()->scrollingContentsLayer());
+            graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
+        }
+    }

[abarth-chromium, 2014/06/13 21:38:15]

Again, this search shouldn't be needed.

+
+    return true;
+}
+
+static FloatPoint convertTargetSpacePointToCompositedLayer(const FloatPoint& point, RenderObject* targetRenderer, RenderObject* compositedRenderer)
+{
+    IntPoint roundedPoint(roundedIntPoint(point));
+    roundedPoint = targetRenderer->frame()->view()->contentsToWindow(roundedPoint);
+    roundedPoint = compositedRenderer->frame()->view()->windowToContents(roundedPoint);
+    return compositedRenderer->absoluteToLocal(roundedPoint, UseTransforms);
+}

[abarth-chromium, 2014/06/13 21:38:14]

If we do this right, we shouldn't need to do any of this sort of coordinate
conversion.

+
+void RenderLayerCompositor::convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, RenderObject* compositedRenderer, FloatQuad& compositedSpaceQuad)
+{
+    ASSERT(targetRenderer);
+    ASSERT(compositedRenderer);
+    compositedSpaceQuad.setP1(convertTargetSpacePointToCompositedLayer(targetSpaceQuad.p1(), targetRenderer, compositedRenderer));
+    compositedSpaceQuad.setP2(convertTargetSpacePointToCompositedLayer(targetSpaceQuad.p2(), targetRenderer, compositedRenderer));
+    compositedSpaceQuad.setP3(convertTargetSpacePointToCompositedLayer(targetSpaceQuad.p3(), targetRenderer, compositedRenderer));
+    compositedSpaceQuad.setP4(convertTargetSpacePointToCompositedLayer(targetSpaceQuad.p4(), targetRenderer, compositedRenderer));
+}

[abarth-chromium, 2014/06/13 21:38:14]

Again, this sort of coordinate conversion shouldn't be necessary in the correct
design.

+
 void RenderLayerCompositor::repaintCompositedLayers()
 {
     recursiveRepaintLayer(rootRenderLayer());
 }
 
 void RenderLayerCompositor::recursiveRepaintLayer(RenderLayer* layer)
 {
     // FIXME: This method does not work correctly with transforms.
     if (layer->compositingState() == PaintsIntoOwnBacking)
         layer->repainter().setBackingNeedsRepaint();
@@ skipping 559 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore