Remove NonCompositedContentHost -- Take 2

Source/WebKit/chromium/src/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
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "LinkHighlight.h"
 
-#include "NonCompositedContentHost.h"
 #include "SkMatrix44.h"
 #include "WebFrameImpl.h"
 #include "WebKit.h"
 #include "WebViewImpl.h"
 #include "core/dom/Node.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
 #include "core/platform/graphics/Color.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderLayerBacking.h"
@@ skipping 18 matching lines @@
 
 PassOwnPtr<LinkHighlight> LinkHighlight::create(Node* node, WebViewImpl* owningWebViewImpl)
 {
     return adoptPtr(new LinkHighlight(node, owningWebViewImpl));
 }
 
 LinkHighlight::LinkHighlight(Node* node, WebViewImpl* owningWebViewImpl)
     : m_node(node)
     , m_owningWebViewImpl(owningWebViewImpl)
     , m_currentGraphicsLayer(0)
-    , m_usingNonCompositedContentHost(false)
     , m_geometryNeedsUpdate(false)
     , m_isAnimating(false)
     , m_startTime(monotonicallyIncreasingTime())
 {
     ASSERT(m_node);
     ASSERT(owningWebViewImpl);
     WebCompositorSupport* compositorSupport = Platform::current()->compositorSupport();
     m_contentLayer = adoptPtr(compositorSupport->createContentLayer(this));
     m_clipLayer = adoptPtr(compositorSupport->createLayer());
     m_clipLayer->setAnchorPoint(WebFloatPoint());
@@ skipping 42 matching lines @@
             if (!renderer)
                 return 0;
         }
     } while (!repaintContainer);
     RenderLayer* renderLayer = repaintContainer->layer();
 
     if (!renderLayer || !renderLayer->isComposited())
         return 0;
 
     GraphicsLayerChromium* newGraphicsLayer = static_cast<GraphicsLayerChromium*>(renderLayer->backing()->graphicsLayer());
-    m_clipLayer->setSublayerTransform(SkMatrix44());
-    m_usingNonCompositedContentHost = !newGraphicsLayer->drawsContent();
-    if (m_usingNonCompositedContentHost ) {
-        m_clipLayer->setSublayerTransform(newGraphicsLayer->platformLayer()->transform());
-        newGraphicsLayer = static_cast<GraphicsLayerChromium*>(m_owningWebViewImpl->nonCompositedContentHost()->topLevelRootLayer());
-    }
-
     if (m_currentGraphicsLayer != newGraphicsLayer) {
         if (m_currentGraphicsLayer)
             clearGraphicsLayerLinkHighlightPointer();
 
         m_currentGraphicsLayer = newGraphicsLayer;
         m_currentGraphicsLayer->setLinkHighlight(this);
     }
 
     return renderLayer;
 }
 
-static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, RenderObject* compositedRenderer, FloatQuad& compositedSpaceQuad)
+static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, RenderLayer* compositedLayer, FloatQuad& compositedSpaceQuad)
 {
     ASSERT(targetRenderer);
-    ASSERT(compositedRenderer);
+    ASSERT(compositedLayer);
+    RenderLayerModelObject* compositedRenderer = compositedLayer->renderer();
 
     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);
+        floatPoint.moveBy(-compositedLayer->backing()->compositedBounds().location());
 
         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 12 matching lines @@
     if (!m_node || !m_node->renderer())
         return false;
 
     ASSERT(compositingLayer);
 
     // Get quads for node in absolute coordinates.
     Vector<FloatQuad> quads;
     m_node->renderer()->absoluteQuads(quads);
     ASSERT(quads.size());
 
-    FloatRect positionAdjust;
-    if (!m_usingNonCompositedContentHost) {
-        const RenderStyle* style = m_node->renderer()->style();
-        // If we have a box shadow, and are non-relative, then must manually adjust
-        // for its size.
-        if (const ShadowData* shadow = style->boxShadow()) {
-            int outlineSize = m_node->renderer()->outlineStyleForRepaint()->outlineSize();
-            shadow->adjustRectForShadow(positionAdjust, outlineSize);
-        }
-
-        // If absolute or fixed, need to subtract out our fixed positioning.
-        // FIXME: should we use RenderLayer::staticBlockPosition() here instead?
-        // Perhaps consider this if out-of-flow elements cause further problems.
-        if (m_node->renderer()->isOutOfFlowPositioned()) {
-            FloatPoint delta(style->left().getFloatValue(), style->top().getFloatValue());
-            positionAdjust.moveBy(delta);
-        }
-    }
-
     Path newPath;
     for (unsigned quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
-
-        FloatQuad localQuad = m_node->renderer()->absoluteToLocalQuad(quads[quadIndex], UseTransforms);
-        localQuad.move(-positionAdjust.location().x(), -positionAdjust.location().y());
-        FloatQuad absoluteQuad = m_node->renderer()->localToAbsoluteQuad(localQuad, UseTransforms);
-
         // Transform node quads in target absolute coords to local coordinates in the compositor layer.
         FloatQuad transformedQuad;
-        convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), compositingLayer->renderer(), transformedQuad);
+        convertTargetSpaceQuadToCompositedLayer(quads[quadIndex], m_node->renderer(), compositingLayer, 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 113 matching lines @@
     // Make sure we update geometry on the next callback from WebViewImpl::layout().
     m_geometryNeedsUpdate = true;
 }
 
 WebLayer* LinkHighlight::layer()
 {
     return clipLayer();
 }
 
 } // namespace WeKit