Implement CSSOM Smooth Scroll API

Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 58 matching lines @@
 #include "core/rendering/TextAutosizer.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "core/rendering/svg/RenderSVGRoot.h"
 #include "core/svg/SVGDocument.h"
 #include "core/svg/SVGSVGElement.h"
 #include "platform/TraceEvent.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsLayerDebugInfo.h"
+#include "platform/scroll/ProgrammaticScrollAnimator.h"
 #include "platform/scroll/ScrollAnimator.h"
 #include "platform/scroll/ScrollbarTheme.h"
 #include "platform/text/TextStream.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/TemporaryChange.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
@@ skipping 197 matching lines @@
             setCanHaveScrollbars(false);
     }
 }
 
 void FrameView::prepareForDetach()
 {
     RELEASE_ASSERT(!isInPerformLayout());
 
     if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
         scrollAnimator->cancelAnimations();
+    cancelProgrammaticScrollAnimation();
 
     detachCustomScrollbars();
     // When the view is no longer associated with a frame, it needs to be removed from the ax object cache
     // right now, otherwise it won't be able to reach the topDocument()'s axObject cache later.
     removeFromAXObjectCache();
 
     if (m_frame->page()) {
         if (ScrollingCoordinator* scrollingCoordinator = m_frame->page()->scrollingCoordinator())
             scrollingCoordinator->willDestroyScrollableArea(this);
     }
@@ skipping 87 matching lines @@
     ScrollView::setFrameRect(newRect);
 
     updateScrollableAreaSet();
 
     if (RenderView* renderView = this->renderView()) {
         if (renderView->usesCompositing())
             renderView->compositor()->frameViewDidChangeSize();
     }
 }
 
+bool FrameView::registerForAnimation()
+{
+    return true;
+}
+
 bool FrameView::scheduleAnimation()
 {
     if (HostWindow* window = hostWindow()) {
         window->scheduleAnimation();
         return true;
     }
     return false;
 }
 
+void FrameView::serviceScrollAnimations(double monotonicTime)
+{
+    ScrollableArea::serviceScrollAnimations(monotonicTime);
+
+    if (!m_animatingScrollableAreas)
+        return;
+
+    for (HashSet<ScrollableArea*>::iterator it = m_animatingScrollableAreas->begin(), end = m_animatingScrollableAreas->end(); it != end; ++it) {
+        ScrollableArea* scrollableArea = *it;
+        scrollableArea->serviceScrollAnimations(monotonicTime);
+    }
+}
+
+bool FrameView::compositedScrollAnimationsEnabled() const
+{
+    if (Settings* settings = m_frame->settings())
+        return settings->compositorDrivenScrollAnimationsEnabled();
+    return false;
+}
+
 RenderView* FrameView::renderView() const
 {
     return frame().contentRenderer();
 }
 
 void FrameView::setCanHaveScrollbars(bool canHaveScrollbars)
 {
     m_canHaveScrollbars = canHaveScrollbars;
     ScrollView::setCanHaveScrollbars(canHaveScrollbars);
 }
@@ skipping 1196 matching lines @@
 void FrameView::scrollElementToRect(Element* element, const IntRect& rect)
 {
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     LayoutRect bounds = element->boundingBox();
     int centeringOffsetX = (rect.width() - bounds.width()) / 2;
     int centeringOffsetY = (rect.height() - bounds.height()) / 2;
     setScrollPosition(IntPoint(bounds.x() - centeringOffsetX - rect.x(), bounds.y() - centeringOffsetY - rect.y()));
 }
 
-void FrameView::setScrollPosition(const IntPoint& scrollPoint)
+void FrameView::setScrollPosition(const IntPoint& scrollPoint, ScrollBehavior scrollBehavior)
 {
+    cancelProgrammaticScrollAnimation();
     TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, true);
     m_maintainScrollPositionAnchor = 0;
 
     IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint);
 
     if (newScrollPosition == scrollPosition())
         return;
 
-    ScrollView::setScrollPosition(newScrollPosition);
+    if (scrollBehavior == ScrollBehaviorAuto)
+        scrollBehavior = m_frame->document()->documentElement()->renderer()->style()->scrollBehavior();
+    ScrollView::setScrollPosition(newScrollPosition, scrollBehavior);
 }
 
 void FrameView::setScrollPositionNonProgrammatically(const IntPoint& scrollPoint)
 {
     IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint);
 
     if (newScrollPosition == scrollPosition())
         return;
 
     TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, false);
@@ skipping 263 matching lines @@
     if (!m_layoutTimer.isActive())
         return;
 
     m_layoutTimer.stop();
     m_delayedLayout = false;
 }
 
 void FrameView::serviceScriptedAnimations(double monotonicAnimationStartTime)
 {
     for (RefPtr<Frame> frame = m_frame; frame; frame = frame->tree().traverseNext()) {
-        frame->view()->serviceScrollAnimations();
+        frame->view()->serviceScrollAnimations(monotonicAnimationStartTime);
         if (!RuntimeEnabledFeatures::webAnimationsCSSEnabled())
             frame->animation().serviceAnimations();
 
         DocumentAnimations::serviceOnAnimationFrame(*frame->document(), monotonicAnimationStartTime);
     }
 
     Vector<RefPtr<Document> > documents;
     for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext())
         documents.append(frame->document());
 
@@ skipping 1210 matching lines @@
         return false;
 
     ScrollableAreaSet::iterator it = m_scrollableAreas->find(scrollableArea);
     if (it == m_scrollableAreas->end())
         return false;
 
     m_scrollableAreas->remove(it);
     return true;
 }
 
+bool FrameView::addAnimatingScrollableArea(ScrollableArea* scrollableArea)
+{
+    ASSERT(scrollableArea);
+    if (!m_animatingScrollableAreas)
+        m_animatingScrollableAreas = adoptPtr(new ScrollableAreaSet);
+    return m_animatingScrollableAreas->add(scrollableArea).isNewEntry;
+}
+
+bool FrameView::removeAnimatingScrollableArea(ScrollableArea* scrollableArea)
+{
+    if (!m_animatingScrollableAreas)
+        return false;
+
+    ScrollableAreaSet::iterator it = m_animatingScrollableAreas->find(scrollableArea);
+    if (it == m_animatingScrollableAreas->end())
+        return false;
+
+    m_animatingScrollableAreas->remove(it);
+    return true;
+}
+
 bool FrameView::containsScrollableArea(const ScrollableArea* scrollableArea) const
 {
     ASSERT(scrollableArea);
     if (!m_scrollableAreas || !scrollableArea)
         return false;
     return m_scrollableAreas->contains(const_cast<ScrollableArea*>(scrollableArea));
 }
 
 void FrameView::removeChild(Widget* widget)
 {
@@ skipping 84 matching lines @@
 void FrameView::willRemoveScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
 {
     ScrollableArea::willRemoveScrollbar(scrollbar, orientation);
     if (AXObjectCache* cache = axObjectCache()) {
         cache->remove(scrollbar);
         cache->handleScrollbarUpdate(this);
     }
 }
 
 } // namespace WebCore