Rework compositor touch hit testing

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 2253 matching lines @@
 }
 
 LayoutRect RenderObject::localCaretRect(InlineBox*, int, LayoutUnit* extraWidthToEndOfLine)
 {
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = 0;
 
     return LayoutRect();
 }
 
+void RenderObject::computeLayerHitTestRects(LayerHitTestRects& layerRects) const
+{
+    // Figure out what layer our container is in. Any offset (or new layer) for this
+    // renderer within it's container will be applied in addLayerHitTestRects.
+    LayoutPoint layerOffset;
+    const RenderLayer* currentLayer = 0;
+
+    if (!hasLayer()) {
+        RenderObject* container = this->container();
+        if (container) {
+            currentLayer = container->enclosingLayer();
+            if (currentLayer && currentLayer->renderer() != container)
+                layerOffset.move(container->offsetFromAncestorContainer(currentLayer->renderer()));
+        } else {
+            currentLayer = enclosingLayer();
+        }
+        if (!currentLayer)
+            return;
+    }
+
+    this->addLayerHitTestRects(layerRects, currentLayer, layerOffset);
+}
+
+void RenderObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const RenderLayer* currentLayer, const LayoutPoint& layerOffset) const
+{
+    ASSERT(currentLayer);
+    ASSERT(currentLayer == this->enclosingLayer());
+
+    // If it's possible for children to have rects outside our bounds, then we need to descend into
+    // the children and compute them.
+    // Ideally there would be other cases where we could detect that children couldn't have rects
+    // outside our bounds and prune the tree walk.
+    // Note that we don't use Region here because Union is O(N) - better to just keep a list of
+    // partially redundant rectangles. If we find examples where this is expensive, then we could
+    // rewrite Region to be more efficient. See https://bugs.webkit.org/show_bug.cgi?id=100814.
+    if (!isRenderView()) {
+        for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+            curr->addLayerHitTestRects(layerRects, currentLayer,  layerOffset);
+        }
+    }
+
+    // Compute the rects for this renderer only and add them to the results.
+    // Note that we could avoid passing the offset and instead adjust each result, but this
+    // seems slightly simpler.
+    Vector<LayoutRect> ownRects;
+    computeSelfHitTestRects(ownRects, layerOffset);
+
+    LayerHitTestRects::iterator iter = layerRects.find(currentLayer);
+    if (iter == layerRects.end())
+        layerRects.add(currentLayer, ownRects);
+    else
+        iter->value.append(ownRects);
+}
+
 bool RenderObject::isRooted(RenderView** view) const
 {
     const RenderObject* o = this;
     while (o->parent())
         o = o->parent();
 
     if (!o->isRenderView())
         return false;
 
     if (view)
@@ skipping 916 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif