AI 145796: Land the WebKit merge @r42026.

Automated import of CL 145796

1 files changed, 147 insertions, 73 deletions

diff --git a/WebCore/rendering/RenderView.cpp b/WebCore/rendering/RenderView.cpp
index 7ce4998..ab2f085 100644
--- a/WebCore/rendering/RenderView.cpp
+++ b/WebCore/rendering/RenderView.cpp
@@ -27,7 +27,15 @@
 #include "Frame.h"
 #include "FrameView.h"
 #include "GraphicsContext.h"
+#include "HitTestResult.h"
 #include "RenderLayer.h"
+#include "RenderSelectionInfo.h"
+#include "RenderWidget.h"
+#include "TransformState.h"
+
+#if USE(ACCELERATED_COMPOSITING)
+#include "RenderLayerCompositor.h"
+#endif
 
 #ifdef ANDROID_LAYOUT
 #include "Settings.h"
@@ -139,39 +147,20 @@ void RenderView::layout()
     setNeedsLayout(false);
 }
 
-FloatPoint RenderView::localToAbsolute(FloatPoint localPoint, bool fixed, bool) const
-{
-    // This disables the css position:fixed to the Browser window. Instead 
-    // the fixed element will be always fixed to the top page.
-#ifndef ANDROID_DISABLE_POSITION_FIXED
-    if (fixed && m_frameView)
-        localPoint += m_frameView->scrollOffset();
-#endif
-    return localPoint;
-}
-
-FloatPoint RenderView::absoluteToLocal(FloatPoint containerPoint, bool fixed, bool) const
-{
-    // This disables the css position:fixed to the Browser window. Instead 
-    // the fixed element will be always fixed to the top page.
-#ifndef ANDROID_DISABLE_POSITION_FIXED
-    if (fixed && m_frameView)
-        containerPoint -= m_frameView->scrollOffset();
-#endif
-    return containerPoint;
-}
-
-FloatQuad RenderView::localToContainerQuad(const FloatQuad& localQuad, RenderBox* repaintContainer, bool fixed) const
+void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool /*useTransforms*/, TransformState& transformState) const
 {
     // If a container was specified, and was not 0 or the RenderView,
     // then we should have found it by now.
     ASSERT_UNUSED(repaintContainer, !repaintContainer || repaintContainer == this);
 
-    FloatQuad quad = localQuad;
     if (fixed && m_frameView)
-        quad += m_frameView->scrollOffset();
+        transformState.move(m_frameView->scrollOffset());
+}
 
-    return quad;
+void RenderView::mapAbsoluteToLocalPoint(bool fixed, bool /*useTransforms*/, TransformState& transformState) const
+{
+    if (fixed && m_frameView)
+        transformState.move(-m_frameView->scrollOffset());
 }
 
 void RenderView::paint(PaintInfo& paintInfo, int tx, int ty)
@@ -230,12 +219,20 @@ void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int, int)
     }
 }
 
-void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
+bool RenderView::shouldRepaint(const IntRect& r) const
 {
-    if (printing() || ur.width() == 0 || ur.height() == 0)
-        return;
+    if (printing() || r.width() == 0 || r.height() == 0)
+        return false;
 
     if (!m_frameView)
+        return false;
+    
+    return true;
+}
+
+void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
+{
+    if (!shouldRepaint(ur))
         return;
 
     // We always just invalidate the root view, since we could be an iframe that is clipped out
@@ -258,7 +255,25 @@ void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
     }
 }
 
-void RenderView::computeRectForRepaint(IntRect& rect, RenderBox* repaintContainer, bool fixed)
+void RenderView::repaintRectangleInViewAndCompositedLayers(const IntRect& ur, bool immediate)
+{
+    if (!shouldRepaint(ur))
+        return;
+
+    repaintViewRectangle(ur, immediate);
+    
+#if USE(ACCELERATED_COMPOSITING)
+    // If we're a frame, repaintViewRectangle will have repainted via a RenderObject in the
+    // parent document.
+    if (document()->ownerElement())
+        return;
+
+    if (compositor()->inCompositingMode())
+        compositor()->repaintCompositedLayersAbsoluteRect(ur);
+#endif
+}
+
+void RenderView::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& rect, bool fixed)
 {
     // If a container was specified, and was not 0 or the RenderView,
     // then we should have found it by now.
@@ -294,21 +309,11 @@ static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset
     return child ? child : object->nextInPreOrderAfterChildren();
 }
 
-IntRect RenderView::selectionRect(bool clipToVisibleContent)
-{
-    // The virtual selectionRect() should never be called on the RenderView.
-    // We assert because there used to be ambiguity between
-    // RenderView::selectionRect(bool) and
-    // virtual RenderObject::selectionRect(bool) const
-    ASSERT_NOT_REACHED();
-    return RenderBlock::selectionRect(clipToVisibleContent);
-}
-
 IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
 {
     document()->updateRendering();
 
-    typedef HashMap<RenderObject*, SelectionInfo*> SelectionMap;
+    typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectionMap;
     SelectionMap selectedObjects;
 
     RenderObject* os = m_selectionStart;
@@ -316,13 +321,13 @@ IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
     while (os && os != stop) {
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
-            selectedObjects.set(os, new SelectionInfo(os, clipToVisibleContent));
+            selectedObjects.set(os, new RenderSelectionInfo(os, clipToVisibleContent));
             RenderBlock* cb = os->containingBlock();
             while (cb && !cb->isRenderView()) {
-                SelectionInfo* blockInfo = selectedObjects.get(cb);
+                RenderSelectionInfo* blockInfo = selectedObjects.get(cb);
                 if (blockInfo)
                     break;
-                selectedObjects.set(cb, new SelectionInfo(cb, clipToVisibleContent));
+                selectedObjects.set(cb, new RenderSelectionInfo(cb, clipToVisibleContent));
                 cb = cb->containingBlock();
             }
         }
@@ -334,13 +339,28 @@ IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
     IntRect selRect;
     SelectionMap::iterator end = selectedObjects.end();
     for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
-        SelectionInfo* info = i->second;
+        RenderSelectionInfo* info = i->second;
         selRect.unite(info->rect());
         delete info;
     }
     return selRect;
 }
 
+#if USE(ACCELERATED_COMPOSITING)
+// Compositing layer dimensions take outline size into account, so we have to recompute layer
+// bounds when it changes.
+// FIXME: This is ugly; it would be nice to have a better way to do this.
+void RenderView::setMaximalOutlineSize(int o)
+{
+    if (o != m_maximalOutlineSize) {
+        m_maximalOutlineSize = o;
+
+        if (m_frameView)
+            m_frameView->updateCompositingLayers(FrameView::ForcedCompositingUpdate);
+    }
+}
+#endif
+
 void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos)
 {
     // Make sure both our start and end objects are defined.
@@ -359,14 +379,14 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     int oldEndPos = m_selectionEndPos;
 
     // Objects each have a single selection rect to examine.
-    typedef HashMap<RenderObject*, SelectionInfo*> SelectedObjectMap;
+    typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectedObjectMap;
     SelectedObjectMap oldSelectedObjects;
     SelectedObjectMap newSelectedObjects;
 
     // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
     // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
     // the union of those rects might remain the same even when changes have occurred.
-    typedef HashMap<RenderBlock*, BlockSelectionInfo*> SelectedBlockMap;
+    typedef HashMap<RenderBlock*, RenderBlockSelectionInfo*> SelectedBlockMap;
     SelectedBlockMap oldSelectedBlocks;
     SelectedBlockMap newSelectedBlocks;
 
@@ -375,13 +395,13 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     while (os && os != stop) {
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
-            oldSelectedObjects.set(os, new SelectionInfo(os, true));
+            oldSelectedObjects.set(os, new RenderSelectionInfo(os, true));
             RenderBlock* cb = os->containingBlock();
             while (cb && !cb->isRenderView()) {
-                BlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
+                RenderBlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
                 if (blockInfo)
                     break;
-                oldSelectedBlocks.set(cb, new BlockSelectionInfo(cb));
+                oldSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
                 cb = cb->containingBlock();
             }
         }
@@ -424,13 +444,13 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     o = start;
     while (o && o != stop) {
         if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
-            newSelectedObjects.set(o, new SelectionInfo(o, true));
+            newSelectedObjects.set(o, new RenderSelectionInfo(o, true));
             RenderBlock* cb = o->containingBlock();
             while (cb && !cb->isRenderView()) {
-                BlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
+                RenderBlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
                 if (blockInfo)
                     break;
-                newSelectedBlocks.set(cb, new BlockSelectionInfo(cb));
+                newSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
                 cb = cb->containingBlock();
             }
         }
@@ -451,14 +471,14 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     // Have any of the old selected objects changed compared to the new selection?
     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
         RenderObject* obj = i->first;
-        SelectionInfo* newInfo = newSelectedObjects.get(obj);
-        SelectionInfo* oldInfo = i->second;
+        RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
+        RenderSelectionInfo* oldInfo = i->second;
         if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
             (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
             (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
-            repaintViewRectangle(oldInfo->rect());
+            oldInfo->repaint();
             if (newInfo) {
-                repaintViewRectangle(newInfo->rect());
+                newInfo->repaint();
                 newSelectedObjects.remove(obj);
                 delete newInfo;
             }
@@ -469,8 +489,8 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
     SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
     for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
-        SelectionInfo* newInfo = i->second;
-        repaintViewRectangle(newInfo->rect());
+        RenderSelectionInfo* newInfo = i->second;
+        newInfo->repaint();
         delete newInfo;
     }
 
@@ -478,12 +498,12 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
     for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
         RenderBlock* block = i->first;
-        BlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
-        BlockSelectionInfo* oldInfo = i->second;
+        RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
+        RenderBlockSelectionInfo* oldInfo = i->second;
         if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
-            repaintViewRectangle(oldInfo->rects());
+            oldInfo->repaint();
             if (newInfo) {
-                repaintViewRectangle(newInfo->rects());
+                newInfo->repaint();
                 newSelectedBlocks.remove(block);
                 delete newInfo;
             }
@@ -494,8 +514,8 @@ void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e
     // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
     SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
     for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
-        BlockSelectionInfo* newInfo = i->second;
-        repaintViewRectangle(newInfo->rects());
+        RenderBlockSelectionInfo* newInfo = i->second;
+        newInfo->repaint();
         delete newInfo;
     }
 }
@@ -518,17 +538,17 @@ bool RenderView::printing() const
 
 void RenderView::updateWidgetPositions()
 {
-    RenderObjectSet::iterator end = m_widgets.end();
-    for (RenderObjectSet::iterator it = m_widgets.begin(); it != end; ++it)
+    RenderWidgetSet::iterator end = m_widgets.end();
+    for (RenderWidgetSet::iterator it = m_widgets.begin(); it != end; ++it)
         (*it)->updateWidgetPosition();
 }
 
-void RenderView::addWidget(RenderObject* o)
+void RenderView::addWidget(RenderWidget* o)
 {
     m_widgets.add(o);
 }
 
-void RenderView::removeWidget(RenderObject* o)
+void RenderView::removeWidget(RenderWidget* o)
 {
     m_widgets.remove(o);
 }
@@ -598,9 +618,17 @@ int RenderView::viewWidth() const
     return width;
 }
 
+float RenderView::zoomFactor() const
+{
+    if (m_frameView->frame() && m_frameView->frame()->shouldApplyPageZoom())
+        return m_frameView->frame()->zoomFactor();
+
+    return 1.0f;
+}
+
 // The idea here is to take into account what object is moving the pagination point, and
 // thus choose the best place to chop it.
-void RenderView::setBestTruncatedAt(int y, RenderBox* forRenderer, bool forcedBreak)
+void RenderView::setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak)
 {
     // Nobody else can set a page break once we have a forced break.
     if (m_forcedPageBreak)
@@ -613,9 +641,10 @@ void RenderView::setBestTruncatedAt(int y, RenderBox* forRenderer, bool forcedBr
         return;
     }
 
-    // prefer the widest object who tries to move the pagination point
-    if (forRenderer->width() > m_truncatorWidth) {
-        m_truncatorWidth = forRenderer->width();
+    // Prefer the widest object that tries to move the pagination point
+    IntRect boundingBox = forRenderer->borderBoundingBox();
+    if (boundingBox.width() > m_truncatorWidth) {
+        m_truncatorWidth = boundingBox.width();
         m_bestTruncatedAt = y;
     }
 }
@@ -629,4 +658,49 @@ void RenderView::pushLayoutState(RenderObject* root)
     m_layoutState = new (renderArena()) LayoutState(root);
 }
 
+void RenderView::updateHitTestResult(HitTestResult& result, const IntPoint& point)
+{
+    if (result.innerNode())
+        return;
+
+    Node* node = document()->documentElement();
+    if (node) {
+        result.setInnerNode(node);
+        if (!result.innerNonSharedNode())
+            result.setInnerNonSharedNode(node);
+        result.setLocalPoint(point);
+    }
+}
+
+#if USE(ACCELERATED_COMPOSITING)
+bool RenderView::usesCompositing() const
+{
+    return m_compositor && m_compositor->inCompositingMode();
+}
+
+RenderLayerCompositor* RenderView::compositor()
+{
+    if (!m_compositor)
+        m_compositor.set(new RenderLayerCompositor(this));
+
+    return m_compositor.get();
+}
+#endif
+
+void RenderView::didMoveOnscreen()
+{
+#if USE(ACCELERATED_COMPOSITING)
+    if (m_compositor)
+        m_compositor->didMoveOnscreen();
+#endif
+}
+
+void RenderView::willMoveOffscreen()
+{
+#if USE(ACCELERATED_COMPOSITING)
+    if (m_compositor)
+        m_compositor->willMoveOffscreen();
+#endif
+}
+
 } // namespace WebCore