Enable navigation in scrollable layers.

EventHandler:
  * Added IgnoreClipping in order to touch nodes that are clipped
    out.

android_graphics:
  * Remember the absolute bounds of the node for invals.

RenderBox:
  * Fix a compiler warning.

RenderLayer:
  * Do not record the entire layer contents unless the scroll
    dimensions are larger than the client dimensions.
  * Change isSelfPaintingLayer to check for an overflow clip
    instead of the scrollable dimensions since it can be too
    early to check at this point.

RenderLayerCompositor:
  * Same as RenderLayer for checking the overflow clip.

WebViewCore:
  * Scroll the containing layer to the node bounds and offset the
    mouse position if scrolled.  Once the mouse event is processed,
    restore the layer to 0,0.

CacheBuilder:
  * The body position is no longer used.
  * Do not clip out nodes if the layer is scrollable.

CachedFrame:
  * Add unadjustBounds to restore adjusted bounds to their original
    position (fixed position elements).
  * Call unadjustBounds when a node has been found.  This new set of
    bounds is passed over to WebViewCore to handle clicks.
  * Reject empty node bounds.

CachedLayer:
  * Document adjustBounds and add unadjustBounds.  Add in the scroll
    position to the node bounds.

CachedRoot:
  * Unadjust the mouse bounds.

WebView:
  * Unadjust the mouse bounds and use the absolute bounds of the ring
    during inval.

Bug: 1566791
Change-Id: Ia55f2cbb61869087176d3ff61882e40324614c6a

1 files changed, 58 insertions, 0 deletions

diff --git a/WebKit/android/jni/WebViewCore.cpp b/WebKit/android/jni/WebViewCore.cpp
index 3da678e..9d2a430 100644
--- a/WebKit/android/jni/WebViewCore.cpp
+++ b/WebKit/android/jni/WebViewCore.cpp
@@ -2357,6 +2357,59 @@ void WebViewCore::touchUp(int touchGeneration,
     handleMouseClick(frame, node);
 }
 
+// Return the RenderLayer for the given RenderObject only if the layer is
+// composited and it contains a scrollable content layer.
+static WebCore::RenderLayer* getLayerFromRenderer(WebCore::RenderObject* renderer)
+{
+    if (!renderer)
+        return 0;
+    WebCore::RenderLayer* layer = renderer->enclosingSelfPaintingLayer();
+    if (!layer || !layer->backing())
+        return 0;
+    GraphicsLayerAndroid* graphicsLayer =
+            static_cast<GraphicsLayerAndroid*>(layer->backing()->graphicsLayer());
+    if (!graphicsLayer)
+        return 0;
+    LayerAndroid* aLayer = graphicsLayer->contentLayer();
+    if (!aLayer || !aLayer->contentIsScrollable())
+        return 0;
+    return layer;
+}
+
+// Scroll the RenderLayer associated with a scrollable div element.  This is
+// done so that the node is visible when it is clicked.
+static void scrollLayer(WebCore::RenderObject* renderer, WebCore::IntPoint* pos)
+{
+    WebCore::RenderLayer* layer = getLayerFromRenderer(renderer);
+    if (!layer)
+        return;
+    WebCore::IntRect absBounds = renderer->absoluteBoundingBoxRect();
+    WebCore::IntRect layerBounds = layer->absoluteBoundingBox();
+
+    // Move the node's bounds into the layer's coordinates.
+    absBounds.move(-layerBounds.x(), -layerBounds.y());
+
+    // Scroll the layer to the node's position.  The false parameters tell the
+    // layer not to invalidate.
+    layer->scrollToOffset(absBounds.x(), absBounds.y(), false, false);
+
+    // Update the mouse position to the layer offset.
+    pos->move(-layer->scrollXOffset(), -layer->scrollYOffset());
+}
+
+static void restoreScrolledLayer(WebCore::RenderObject* renderer,
+        WebCore::IntPoint* pos)
+{
+    WebCore::RenderLayer* layer = getLayerFromRenderer(renderer);
+    if (!layer)
+        return;
+    // Move the mouse position back to it's original position.
+    pos->move(layer->scrollXOffset(), layer->scrollYOffset());
+
+    // Scroll the layer back to 0,0.
+    layer->scrollToOffset(0, 0, false, false);
+}
+
 // Common code for both clicking with the trackball and touchUp
 bool WebViewCore::handleMouseClick(WebCore::Frame* framePtr, WebCore::Node* nodePtr)
 {
@@ -2373,6 +2426,7 @@ bool WebViewCore::handleMouseClick(WebCore::Frame* framePtr, WebCore::Node* node
             DBG_NAV_LOG("area");
             return true;
         }
+
         WebCore::RenderObject* renderer = nodePtr->renderer();
         if (renderer && (renderer->isMenuList() || renderer->isListBox())) {
             WebCore::HTMLSelectElement* select = static_cast<WebCore::HTMLSelectElement*>(nodePtr);
@@ -2415,6 +2469,8 @@ bool WebViewCore::handleMouseClick(WebCore::Frame* framePtr, WebCore::Node* node
     }
     if (!valid || !framePtr)
         framePtr = m_mainFrame;
+    if (nodePtr && valid)
+        scrollLayer(nodePtr->renderer(), &m_mousePos);
     webFrame->setUserInitiatedClick(true);
     WebCore::PlatformMouseEvent mouseDown(m_mousePos, m_mousePos, WebCore::LeftButton,
             WebCore::MouseEventPressed, 1, false, false, false, false,
@@ -2451,6 +2507,8 @@ bool WebViewCore::handleMouseClick(WebCore::Frame* framePtr, WebCore::Node* node
             requestKeyboard(true);
         }
     }
+    if (nodePtr && valid)
+        restoreScrolledLayer(nodePtr->renderer(), &m_mousePos);
     return handled;
 }