Merge 141252

Source/WebKit/chromium/src/FindInPageCoordinates.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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 #include "RenderBox.h"
 #include "RenderObject.h"
 #include "RenderPart.h"
 #include "RenderStyle.h"
 #include "RenderView.h"
 
 using namespace WebCore;
 
 namespace WebKit {
 
-static FloatRect toNormalizedRect(const FloatRect& absoluteRect, const RenderObject* renderer)
+static const RenderBlock* enclosingScrollableAncestor(const RenderObject* renderer)
+{
+    ASSERT(!renderer->isRenderView());
+
+    // Trace up the containingBlocks until we reach either the render view or a scrollable object.
+    const RenderBlock* container = renderer->containingBlock();
+    while (!container->hasOverflowClip() && !container->isRenderView())
+        container = container->containingBlock();
+    return container;
+}
+
+static FloatRect toNormalizedRect(const FloatRect& absoluteRect, const RenderObject* renderer, const RenderBlock* container)
 {
     ASSERT(renderer);
 
-    const RenderBlock* container = renderer->containingBlock();
     ASSERT(container || renderer->isRenderView());
     if (!container)
         return FloatRect();
 
     // We want to normalize by the max layout overflow size instead of only the visible bounding box.
     // Quads and their enclosing bounding boxes need to be used in order to keep results transform-friendly.
     FloatPoint scrolledOrigin;
 
     // For overflow:scroll we need to get where the actual origin is independently of the scroll.
     if (container->hasOverflowClip())
@@ skipping 18 matching lines @@
     normalizedRect.scale(1 / containerRect.width(), 1 / containerRect.height());
     return normalizedRect;
 }
 
 FloatRect findInPageRectFromAbsoluteRect(const FloatRect& inputRect, const RenderObject* baseRenderer)
 {
     if (!baseRenderer || inputRect.isEmpty())
         return FloatRect();
 
     // Normalize the input rect to its container block.
-    FloatRect normalizedRect = toNormalizedRect(inputRect, baseRenderer);
+    const RenderBlock* baseContainer = enclosingScrollableAncestor(baseRenderer);
+    FloatRect normalizedRect = toNormalizedRect(inputRect, baseRenderer, baseContainer);
 
     // Go up across frames.
-    for (const RenderObject* renderer = baseRenderer->containingBlock(); renderer; ) {
+    for (const RenderBox* renderer = baseContainer; renderer; ) {
 
         // Go up the render tree until we reach the root of the current frame (the RenderView).
-        for (const RenderBlock* container = renderer->containingBlock(); container;
-                renderer = container, container = container->containingBlock()) {
+        while (!renderer->isRenderView()) {
+            const RenderBlock* container = enclosingScrollableAncestor(renderer);
 
             // Compose the normalized rects.
-            FloatRect normalizedBoxRect = toNormalizedRect(renderer->absoluteBoundingBoxRect(), renderer);
+            FloatRect normalizedBoxRect = toNormalizedRect(renderer->absoluteBoundingBoxRect(), renderer, container);
             normalizedRect.scale(normalizedBoxRect.width(), normalizedBoxRect.height());
             normalizedRect.moveBy(normalizedBoxRect.location());
 
-            if (normalizedRect.isEmpty())
-                return normalizedRect;
+            renderer = container;
         }
 
+        ASSERT(renderer->isRenderView());
+
         // Jump to the renderer owning the frame, if any.
-        ASSERT(renderer->isRenderView());
         renderer = renderer->frame() ? renderer->frame()->ownerRenderer() : 0;
     }
 
     return normalizedRect;
 }
 
 FloatRect findInPageRectFromRange(Range* range)
 {
     if (!range || !range->firstNode())
         return FloatRect();
 
     return findInPageRectFromAbsoluteRect(RenderObject::absoluteBoundingBoxRectForRange(range), range->firstNode()->renderer());
 }
 
 } // namespace WebKit