Fix for <rdar://problem/8944558> Overlay scrollers in overflow areas need to

send notifications appropriate times (showing up, resizing)
-and corresponding-
https://bugs.webkit.org/show_bug.cgi?id=56067

Reviewed by Darin Adler.

The general strategy here is to add a HashSet of ScrollableAreas to the page that 
can be accessed when necessary to send notifications to all ScrollableAreas. In 
turn, all of the ScrollableArea classes that add themselves to the HashSet must 
keep a weak pointer to Page so that they can remove themselves without relying on 
Frames or Renderers to still have references.

Find layers for relevant node and if the layers are in the Page's ScrollableArea 
set, then send the relevant notification.
* page/EventHandler.cpp:
(WebCore::layerForNode):
(WebCore::EventHandler::mouseMoved):
(WebCore::EventHandler::updateMouseEventTargetNode):

When the page is set active or not active, iterate through the Page's 
ScrollableAreas to send hide/show notifications. 
* page/FocusController.cpp:
(WebCore::FocusController::setActive):

When a FrameView is created, add it to the ScrollableArea set. When it's 
destroyed, remove it.
* page/FrameView.cpp:
(WebCore::FrameView::FrameView):
(WebCore::FrameView::~FrameView):

Iterate through the Page's ScrollableAreas to send the paint notification.
(WebCore::FrameView::notifyPageThatContentAreaWillPaint):
* page/FrameView.h:
(WebCore::FrameView::disconnectFromPage):

Add the new ScrollableArea set.
* page/Page.cpp:
(WebCore::Page::~Page):
(WebCore::Page::addScrollableArea):



git-svn-id: svn://svn.chromium.org/blink/trunk@81209 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/WebCore/ChangeLog

+2011-03-15  Beth Dakin  <bdakin@apple.com>
+
+        Reviewed by Darin Adler.
+
+        Fix for <rdar://problem/8944558> Overlay scrollers in overflow areas need to 
+        send notifications appropriate times (showing up, resizing)
+        -and corresponding-
+        https://bugs.webkit.org/show_bug.cgi?id=56067
+
+        The general strategy here is to add a HashSet of ScrollableAreas to the page that 
+        can be accessed when necessary to send notifications to all ScrollableAreas. In 
+        turn, all of the ScrollableArea classes that add themselves to the HashSet must 
+        keep a weak pointer to Page so that they can remove themselves without relying on 
+        Frames or Renderers to still have references.
+
+        Find layers for relevant node and if the layers are in the Page's ScrollableArea 
+        set, then send the relevant notification.
+        * page/EventHandler.cpp:
+        (WebCore::layerForNode):
+        (WebCore::EventHandler::mouseMoved):
+        (WebCore::EventHandler::updateMouseEventTargetNode):
+
+        When the page is set active or not active, iterate through the Page's 
+        ScrollableAreas to send hide/show notifications. 
+        * page/FocusController.cpp:
+        (WebCore::FocusController::setActive):
+
+        When a FrameView is created, add it to the ScrollableArea set. When it's 
+        destroyed, remove it.
+        * page/FrameView.cpp:
+        (WebCore::FrameView::FrameView):
+        (WebCore::FrameView::~FrameView):
+
+        Iterate through the Page's ScrollableAreas to send the paint notification.
+        (WebCore::FrameView::notifyPageThatContentAreaWillPaint):
+        * page/FrameView.h:
+        (WebCore::FrameView::disconnectFromPage):
+
+        Add the new ScrollableArea set.
+        * page/Page.cpp:
+        (WebCore::Page::~Page):
+        (WebCore::Page::addScrollableArea):
+(WebCore::Page::removeScrollableArea):
+        (WebCore::Page::containsScrollableArea):
+        * page/Page.h:
+        (WebCore::Page::scrollableAreaSet):
+
+        notifyPageThatContentAreaWillPaint() is a dummy function implemented in FrameView.
+        * platform/ScrollView.cpp:
+        (WebCore::ScrollView::notifyPageThatContentAreaWillPaint):
+        
+        Call notifyPageThatContentAreaWillPaint() instead of calling 
+        contentAreaWillPaint() just for the ScrollView.
+        (WebCore::ScrollView::paint):
+        * platform/ScrollView.h:
+
+        Add/remove ScrollableAreas to the set. Add new disconnectFromPage().
+        * platform/ScrollableArea.h:
+        (WebCore::ScrollableArea::disconnectFromPage):
+        * rendering/RenderDataGrid.cpp:
+        (WebCore::RenderDataGrid::RenderDataGrid):
+        (WebCore::RenderDataGrid::~RenderDataGrid):
+        * rendering/RenderDataGrid.h:
+        (WebCore::RenderDataGrid::disconnectFromPage):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::RenderLayer):
+        (WebCore::RenderLayer::~RenderLayer):
+        * rendering/RenderLayer.h:
+        (WebCore::RenderLayer::disconnectFromPage):
+        * rendering/RenderListBox.cpp:
+        (WebCore::RenderListBox::RenderListBox):
+        (WebCore::RenderListBox::~RenderListBox):
+        * rendering/RenderListBox.h:
+        (WebCore::RenderListBox::disconnectFromPage):
+
+        Should have implemented this ScrollableArea-interface function a while ago.
+        (WebCore::RenderLayer::currentMousePosition):
+
 2011-03-15  Brady Eidson  <beidson@apple.com>
 
         Reviewed by Sam Weinig.

third_party/WebKit/Source/WebCore/page/EventHandler.cpp

@@ -1452,6 +1452,22 @@ bool EventHandler::handleMouseDoubleClickEvent(const PlatformMouseEvent& mouseEv
     return swallowMouseUpEvent || swallowClickEvent || swallowMouseReleaseEvent;
 }
 
+static RenderLayer* layerForNode(Node* node)
+{
+    if (!node)
+        return 0;
+
+    RenderObject* renderer = node->renderer();
+    if (!renderer)
+        return 0;
+
+    RenderLayer* layer = renderer->enclosingLayer();
+    if (!layer)
+        return 0;
+
+    return layer;
+}
+
 bool EventHandler::mouseMoved(const PlatformMouseEvent& event)
 {
     HitTestResult hoveredNode = HitTestResult(IntPoint());
@@ -1461,6 +1477,11 @@ bool EventHandler::mouseMoved(const PlatformMouseEvent& event)
     if (!page)
         return result;
 
+    if (RenderLayer* layer = layerForNode(hoveredNode.innerNode())) {
+        if (page->containsScrollableArea(layer))
+            layer->scrollAnimator()->mouseMovedInContentArea();
+    }
+
     if (FrameView* frameView = m_frame->view())
         frameView->scrollAnimator()->mouseMovedInContentArea();  
 
@@ -1871,21 +1892,32 @@ void EventHandler::updateMouseEventTargetNode(Node* targetNode, const PlatformMo
 
     // Fire mouseout/mouseover if the mouse has shifted to a different node.
     if (fireMouseOverOut) {
-        // FIXME: This code will only correctly handle transitions between frames with scrollbars,
-        // not transitions between overflow regions, or transitions between two frames
-        // that don't have scrollbars contained within a frame that does.
+        RenderLayer* layerForLastNode = layerForNode(m_lastNodeUnderMouse.get());
+        RenderLayer* layerForNodeUnderMouse = layerForNode(m_nodeUnderMouse.get());
+        Page* page = m_frame->page();
+
         if (m_lastNodeUnderMouse && (!m_nodeUnderMouse || m_nodeUnderMouse->document() != m_frame->document())) {
+            // The mouse has moved between frames.
             if (Frame* frame = m_lastNodeUnderMouse->document()->frame()) {
                 if (FrameView* frameView = frame->view())
                     frameView->scrollAnimator()->mouseExitedContentArea();
             }
+        } else if (page && (layerForLastNode && (!layerForNodeUnderMouse || layerForNodeUnderMouse != layerForLastNode))) {
+            // The mouse has moved between layers.
+            if (page->containsScrollableArea(layerForLastNode))
+                layerForLastNode->scrollAnimator()->mouseExitedContentArea();
         }
         
         if (m_nodeUnderMouse && (!m_lastNodeUnderMouse || m_lastNodeUnderMouse->document() != m_frame->document())) {
+            // The mouse has moved between frames.
             if (Frame* frame = m_nodeUnderMouse->document()->frame()) {
                 if (FrameView* frameView = frame->view())
                     frameView->scrollAnimator()->mouseEnteredContentArea();
             }
+        } else if (page && (layerForNodeUnderMouse && (!layerForLastNode || layerForNodeUnderMouse != layerForLastNode))) {
+            // The mouse has moved between layers.
+            if (page->containsScrollableArea(layerForNodeUnderMouse))
+                layerForNodeUnderMouse->scrollAnimator()->mouseEnteredContentArea();
         }
         
         if (m_lastNodeUnderMouse && m_lastNodeUnderMouse->document() != m_frame->document()) {

third_party/WebKit/Source/WebCore/page/FocusController.cpp

@@ -410,11 +410,16 @@ void FocusController::setActive(bool active)
             view->updateLayoutAndStyleIfNeededRecursive();
             view->updateControlTints();
         }
-        // FIXME: This should propogate to all ScrollableAreas.
-        if (!active)
-            view->scrollAnimator()->contentAreaDidHide();
-        else
-            view->scrollAnimator()->contentAreaDidShow();
+
+        if (const HashSet<ScrollableArea*>* scrollableAreas = m_page->scrollableAreaSet()) {
+            HashSet<ScrollableArea*>::const_iterator end = scrollableAreas->end(); 
+            for (HashSet<ScrollableArea*>::const_iterator it = scrollableAreas->begin(); it != end; ++it) {
+                if (!active)
+                    (*it)->scrollAnimator()->contentAreaDidHide();
+                else
+                    (*it)->scrollAnimator()->contentAreaDidShow();
+            }
+        }
     }
 
     focusedOrMainFrame()->selection()->pageActivationChanged();

third_party/WebKit/Source/WebCore/page/FrameView.cpp

@@ -136,6 +136,13 @@ FrameView::FrameView(Frame* frame)
     , m_scrollCorner(0)
 {
     init();
+
+    if (m_frame) {
+        if (Page* page = m_frame->page()) {
+            m_page = page;
+            m_page->addScrollableArea(this);
+        }
+    }
 }
 
 PassRefPtr<FrameView> FrameView::create(Frame* frame)
@@ -176,6 +183,9 @@ FrameView::~FrameView()
     ASSERT(!m_scrollCorner);
     ASSERT(m_actionScheduler->isEmpty());
 
+    if (m_page)
+        m_page->removeScrollableArea(this);
+
     if (m_frame) {
         ASSERT(m_frame->view() != this || !m_frame->contentRenderer());
         RenderPart* renderer = m_frame->ownerRenderer();
@@ -2055,6 +2065,18 @@ bool FrameView::shouldSuspendScrollAnimations() const
     return m_frame->loader()->state() != FrameStateComplete;
 }
 
+void FrameView::notifyPageThatContentAreaWillPaint() const
+{
+    Page* page = m_frame->page();
+    const HashSet<ScrollableArea*>* scrollableAreas = page->scrollableAreaSet();
+    if (!scrollableAreas)
+        return;
+
+    HashSet<ScrollableArea*>::const_iterator end = scrollableAreas->end(); 
+    for (HashSet<ScrollableArea*>::const_iterator it = scrollableAreas->begin(); it != end; ++it)
+        (*it)->scrollAnimator()->contentAreaWillPaint();
+}
+
 #if ENABLE(DASHBOARD_SUPPORT)
 void FrameView::updateDashboardRegions()
 {

third_party/WebKit/Source/WebCore/page/FrameView.h

@@ -319,6 +319,9 @@ private:
     virtual void scrollTo(const IntSize&);
     virtual void didCompleteRubberBand(const IntSize&) const;
 
+    virtual void notifyPageThatContentAreaWillPaint() const;
+    virtual void disconnectFromPage() { m_page = 0; }
+
     void deferredRepaintTimerFired(Timer<FrameView>*);
     void doDeferredRepaints();
     void updateDeferredRepaintDelay();
@@ -418,6 +421,8 @@ private:
     // Renderer to hold our custom scroll corner.
     RenderScrollbarPart* m_scrollCorner;
 
+    Page* m_page;
+
     static double s_deferredRepaintDelay;
     static double s_initialDeferredRepaintDelayDuringLoading;
     static double s_maxDeferredRepaintDelayDuringLoading;

third_party/WebKit/Source/WebCore/page/Page.cpp

@@ -191,6 +191,12 @@ Page::~Page()
     for (Frame* frame = mainFrame(); frame; frame = frame->tree()->traverseNext())
         frame->pageDestroyed();
 
+    if (m_scrollableAreaSet) {
+        ScrollableAreaSet::const_iterator end = m_scrollableAreaSet->end(); 
+        for (ScrollableAreaSet::const_iterator it = m_scrollableAreaSet->begin(); it != end; ++it)
+            (*it)->disconnectFromPage();
+    }
+
     m_editorClient->pageDestroyed();
 
     InspectorInstrumentation::inspectedPageDestroyed(this);
@@ -892,6 +898,27 @@ void Page::didStopPlugin(HaltablePlugin* obj)
         m_pluginHalter->didStopPlugin(obj);
 }
 
+void Page::addScrollableArea(ScrollableArea* scrollableArea)
+{
+    if (!m_scrollableAreaSet)
+        m_scrollableAreaSet = adoptPtr(new ScrollableAreaSet);
+    m_scrollableAreaSet->add(scrollableArea);
+}
+
+void Page::removeScrollableArea(ScrollableArea* scrollableArea)
+{
+    if (!m_scrollableAreaSet)
+        return;
+    m_scrollableAreaSet->remove(scrollableArea);
+}
+
+bool Page::containsScrollableArea(ScrollableArea* scrollableArea) const
+{
+    if (!m_scrollableAreaSet)
+        return false;
+    return m_scrollableAreaSet->contains(scrollableArea);
+}
+
 #if !ASSERT_DISABLED
 void Page::checkFrameCountConsistency() const
 {

third_party/WebKit/Source/WebCore/page/Page.h

@@ -70,6 +70,7 @@ namespace WebCore {
     class ProgressTracker;
     class RenderTheme;
     class VisibleSelection;
+    class ScrollableArea;
     class SelectionController;
     class Settings;
     class SharedGraphicsContext3D;
@@ -279,6 +280,12 @@ namespace WebCore {
         void setJavaScriptURLsAreAllowed(bool);
         bool javaScriptURLsAreAllowed() const;
 
+        typedef HashSet<ScrollableArea*> ScrollableAreaSet;
+        void addScrollableArea(ScrollableArea*);
+        void removeScrollableArea(ScrollableArea*);
+        bool containsScrollableArea(ScrollableArea*) const;
+        const ScrollableAreaSet* scrollableAreaSet() const { return m_scrollableAreaSet.get(); }
+
         // Don't allow more than a certain number of frames in a page.
         // This seems like a reasonable upper bound, and otherwise mutually
         // recursive frameset pages can quickly bring the program to its knees
@@ -386,6 +393,8 @@ namespace WebCore {
         ViewportArguments m_viewportArguments;
 
         double m_minimumTimerInterval;
+
+        OwnPtr<ScrollableAreaSet> m_scrollableAreaSet;
     };
 
 } // namespace WebCore

third_party/WebKit/Source/WebCore/platform/ScrollView.cpp

@@ -327,6 +327,10 @@ void ScrollView::didCompleteRubberBand(const IntSize&) const
 {
 }
 
+void ScrollView::notifyPageThatContentAreaWillPaint() const
+{
+}
+
 void ScrollView::setScrollOffset(const IntPoint& offset)
 {
     int horizontalOffset = offset.x();
@@ -917,7 +921,7 @@ void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
     if (context->paintingDisabled() && !context->updatingControlTints())
         return;
 
-    scrollAnimator()->contentAreaWillPaint();
+    notifyPageThatContentAreaWillPaint();
     
     IntRect documentDirtyRect = rect;
     documentDirtyRect.intersect(frameRect());

third_party/WebKit/Source/WebCore/platform/ScrollView.h

@@ -62,6 +62,7 @@ public:
     virtual int scrollPosition(Scrollbar*) const;
     virtual void setScrollOffset(const IntPoint&);
     virtual void didCompleteRubberBand(const IntSize&) const;
+    virtual void notifyPageThatContentAreaWillPaint() const;
 
     // NOTE: This should only be called by the overriden setScrollOffset from ScrollableArea.
     virtual void scrollTo(const IntSize& newOffset);

third_party/WebKit/Source/WebCore/platform/ScrollableArea.h

@@ -117,6 +117,8 @@ public:
     virtual void didCompleteRubberBand(const IntSize&) const { ASSERT_NOT_REACHED(); }
     virtual bool shouldSuspendScrollAnimations() const { return true; }
 
+    virtual void disconnectFromPage() { }
+
 private:
     // NOTE: Only called from the ScrollAnimator.
     friend class ScrollAnimator;

third_party/WebKit/Source/WebCore/rendering/RenderDataGrid.cpp

@@ -46,10 +46,16 @@ static const int cDefaultWidth = 300;
 RenderDataGrid::RenderDataGrid(Element* elt)
     : RenderBlock(elt)
 {
+    if (Page* page = frame()->page()) {
+        m_page = page;
+        m_page->addScrollableArea(this);
+    }
 }
 
 RenderDataGrid::~RenderDataGrid()
 {
+    if (m_page)
+        m_page->removeScrollableArea(this);
 }
 
 void RenderDataGrid::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)

third_party/WebKit/Source/WebCore/rendering/RenderDataGrid.h

@@ -79,7 +79,11 @@ private:
     virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
     virtual bool shouldSuspendScrollAnimations() const;
 
+    virtual void disconnectFromPage() { m_page = 0; }
+
     RefPtr<Scrollbar> m_vBar;
+
+    Page* m_page;
 };
 
 }

third_party/WebKit/Source/WebCore/rendering/RenderLayer.cpp

@@ -188,6 +188,13 @@ RenderLayer::RenderLayer(RenderBoxModelObject* renderer)
         m_visibleContentStatusDirty = false;
         m_hasVisibleContent = renderer->style()->visibility() == VISIBLE;
     }
+
+    if (Frame* frame = renderer->frame()) {
+        if (Page* page = frame->page()) {
+            m_page = page;
+            m_page->addScrollableArea(this);
+        }
+    }
 }
 
 RenderLayer::~RenderLayer()
@@ -197,6 +204,9 @@ RenderLayer::~RenderLayer()
             frame->eventHandler()->resizeLayerDestroyed();
     }
 
+    if (m_page)
+        m_page->removeScrollableArea(this);
+
     destroyScrollbar(HorizontalScrollbar);
     destroyScrollbar(VerticalScrollbar);
 
@@ -1786,6 +1796,11 @@ bool RenderLayer::shouldSuspendScrollAnimations() const
     return view->frameView()->shouldSuspendScrollAnimations();
 }
 
+IntPoint RenderLayer::currentMousePosition() const
+{
+    return renderer()->frame() ? renderer()->frame()->eventHandler()->currentMousePosition() : IntPoint();
+}
+
 IntSize RenderLayer::scrollbarOffset(const Scrollbar* scrollbar) const
 {
     RenderBox* box = renderBox();

third_party/WebKit/Source/WebCore/rendering/RenderLayer.h

@@ -525,8 +525,11 @@ private:
     virtual IntSize contentsSize() const;
     virtual int visibleHeight() const;
     virtual int visibleWidth() const;
+    virtual IntPoint currentMousePosition() const;
     virtual bool shouldSuspendScrollAnimations() const;
 
+    virtual void disconnectFromPage() { m_page = 0; }
+
     // NOTE: This should only be called by the overriden setScrollOffset from ScrollableArea.
     void scrollTo(int x, int y);
 
@@ -700,6 +703,8 @@ private:
 #if USE(ACCELERATED_COMPOSITING)
     OwnPtr<RenderLayerBacking> m_backing;
 #endif
+
+    Page* m_page;
 };
 
 } // namespace WebCore