Get rid of ScrollView.

sky/engine/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 79 matching lines @@
     , m_isTrackingPaintInvalidations(false)
     , m_hasSoftwareFilters(false)
     , m_visibleContentScaleFactor(1)
     , m_inputEventsScaleFactorForEmulation(1)
     , m_layoutSizeFixedToFrameSize(true)
     , m_didScrollTimer(this, &FrameView::didScrollTimerFired)
     , m_needsUpdateWidgetPositions(false)
 {
     ASSERT(m_frame);
     init();
-
-    ScrollableArea::setVerticalScrollElasticity(ScrollElasticityAllowed);
-    ScrollableArea::setHorizontalScrollElasticity(ScrollElasticityAllowed);
 }
 
 PassRefPtr<FrameView> FrameView::create(LocalFrame* frame)
 {
     RefPtr<FrameView> view = adoptRef(new FrameView(frame));
     view->show();
     return view.release();
 }
 
 PassRefPtr<FrameView> FrameView::create(LocalFrame* frame, const IntSize& initialSize)
 {
     RefPtr<FrameView> view = adoptRef(new FrameView(frame));
     view->Widget::setFrameRect(IntRect(view->location(), initialSize));
     view->setLayoutSizeInternal(initialSize);
 
     view->show();
     return view.release();
 }
 
 FrameView::~FrameView()
 {
     if (m_postLayoutTasksTimer.isActive())
         m_postLayoutTasksTimer.stop();
 
     if (m_didScrollTimer.isActive())
         m_didScrollTimer.stop();
 
-    resetScrollbars();
-
-    // Custom scrollbars should already be destroyed at this point
-    ASSERT(!horizontalScrollbar() || !horizontalScrollbar()->isCustomScrollbar());
-    ASSERT(!verticalScrollbar() || !verticalScrollbar()->isCustomScrollbar());
-
-    setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow.
-    setHasVerticalScrollbar(false);
-
     ASSERT(m_frame);
     ASSERT(m_frame->view() != this || !m_frame->contentRenderer());
     // FIXME: Do we need to do something here for OOPI?
 }
 
 void FrameView::reset()
 {
     m_hasPendingLayout = false;
     m_layoutSubtreeRoot = 0;
     m_doFullPaintInvalidation = false;
@@ skipping 10 matching lines @@
     m_lastViewportSize = IntSize();
     m_lastZoomFactor = 1.0f;
     m_isTrackingPaintInvalidations = false;
     m_trackedPaintInvalidationRects.clear();
     m_lastPaintTime = 0;
     m_paintBehavior = PaintBehaviorNormal;
     m_isPainting = false;
     m_viewportConstrainedObjects.clear();
 }
 
-void FrameView::resetScrollbars()
-{
-    // Reset the document's scrollbars back to our defaults before we yield the floor.
-    m_firstLayout = true;
-    setScrollbarsSuppressed(true);
-    if (m_canHaveScrollbars)
-        setScrollbarModes(ScrollbarAuto, ScrollbarAuto);
-    else
-        setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
-    setScrollbarsSuppressed(false);
-}
-
 void FrameView::init()
 {
     reset();
 
     m_size = LayoutSize();
 }
 
 void FrameView::prepareForDetach()
 {
-    RELEASE_ASSERT(!isInPerformLayout());
-
-    if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
-        scrollAnimator->cancelAnimations();
-    cancelProgrammaticScrollAnimation();
-
-    if (m_frame->page()) {
-        if (ScrollingCoordinator* scrollingCoordinator = m_frame->page()->scrollingCoordinator())
-            scrollingCoordinator->willDestroyScrollableArea(this);
-    }
+    // FIXME(sky): Remove
 }
 
 void FrameView::recalculateScrollbarOverlayStyle()
 {
-    ScrollbarOverlayStyle oldOverlayStyle = scrollbarOverlayStyle();
-    ScrollbarOverlayStyle overlayStyle = ScrollbarOverlayStyleDefault;
-
-    Color backgroundColor = documentBackgroundColor();
-    // Reduce the background color from RGB to a lightness value
-    // and determine which scrollbar style to use based on a lightness
-    // heuristic.
-    double hue, saturation, lightness;
-    backgroundColor.getHSL(hue, saturation, lightness);
-    if (lightness <= .5)
-        overlayStyle = ScrollbarOverlayStyleLight;
-
-    if (oldOverlayStyle != overlayStyle)
-        setScrollbarOverlayStyle(overlayStyle);
+    // FIXME(sky): Remove.
 }
 
 void FrameView::clear()
 {
     reset();
-    setScrollbarsSuppressed(true);
 }
 
 bool FrameView::didFirstLayout() const
 {
     return !m_firstLayout;
 }
 
 void FrameView::invalidateRect(const IntRect& rect)
 {
     // For querying RenderLayer::compositingState() when invalidating scrollbars.
     // FIXME: do all scrollbar invalidations after layout of all frames is complete. It's currently not recursively true.
     DisableCompositingQueryAsserts disabler;
     if (!parent()) {
         if (HostWindow* window = hostWindow())
             window->invalidateContentsAndRootView(rect);
         return;
     }
 }
 
 void FrameView::setFrameRect(const IntRect& newRect)
 {
     IntRect oldRect = frameRect();
     if (newRect == oldRect)
         return;
 
-    ScrollView::setFrameRect(newRect);
+    Widget::setFrameRect(newRect);
 
     if (RenderView* renderView = this->renderView()) {
         if (renderView->usesCompositing())
             renderView->compositor()->frameViewDidChangeSize();
     }
 
     viewportConstrainedVisibleContentSizeChanged(newRect.width() != oldRect.width(), newRect.height() != oldRect.height());
 
     if (oldRect.size() != newRect.size()
         && m_frame->settings()->pinchVirtualViewportEnabled())
         page()->frameHost().pinchViewport().mainFrameDidChangeSize();
 }
 
 Page* FrameView::page() const
 {
     return frame().page();
 }
 
 RenderView* FrameView::renderView() const
 {
     return frame().contentRenderer();
 }
 
 void FrameView::setCanHaveScrollbars(bool canHaveScrollbars)
 {
-    m_canHaveScrollbars = canHaveScrollbars;
-    ScrollView::setCanHaveScrollbars(canHaveScrollbars);
+    // FIXME(sky): Remove
 }
 
-void FrameView::setContentsSize(const IntSize& size)
+void FrameView::setContentsSize(const IntSize&)
 {
-    if (size == contentsSize())
-        return;
-
-    ScrollView::setContentsSize(size);
-    ScrollView::contentsResized();
+    // FIXME(sky): Remove
 }
 
 IntPoint FrameView::clampOffsetAtScale(const IntPoint& offset, float scale) const
 {
-    IntPoint maxScrollExtent(contentsSize().width() - scrollOrigin().x(), contentsSize().height() - scrollOrigin().y());
     FloatSize scaledSize = unscaledVisibleContentSize();
     if (scale)
         scaledSize.scale(1 / scale);
 
     IntPoint clampedOffset = offset;
-    clampedOffset = clampedOffset.shrunkTo(maxScrollExtent - expandedIntSize(scaledSize));
+    clampedOffset = clampedOffset.shrunkTo(
+        IntPoint(size()) - expandedIntSize(scaledSize));
     clampedOffset = clampedOffset.expandedTo(-scrollOrigin());
 
     return clampedOffset;
 }
 
 void FrameView::adjustViewSize()
 {
     RenderView* renderView = this->renderView();
     if (!renderView)
         return;
 
     ASSERT(m_frame->view() == this);
 
     const IntRect rect = renderView->documentRect();
     const IntSize& size = rect.size();
-    ScrollView::setScrollOrigin(IntPoint(-rect.x(), -rect.y()), true, size == contentsSize());
-
     setContentsSize(size);
 }
 
 void FrameView::applyOverflowToViewportAndSetRenderer(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)
 {
     // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats
     // overflow:hidden and overflow:scroll on <body> as applying to the document's
     // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should
     // use the root element.
 
@@ skipping 65 matching lines @@
 void FrameView::recalcOverflowAfterStyleChange()
 {
     RenderView* renderView = this->renderView();
     RELEASE_ASSERT(renderView);
     if (!renderView->needsOverflowRecalcAfterStyleChange())
         return;
 
     renderView->recalcOverflowAfterStyleChange();
 
     IntRect documentRect = renderView->documentRect();
-    if (scrollOrigin() == -documentRect.location() && contentsSize() == documentRect.size())
+    if (size() == documentRect.size())
         return;
 
     if (needsLayout())
         return;
 
-    InUpdateScrollbarsScope inUpdateScrollbarsScope(this);
-
-    bool shouldHaveHorizontalScrollbar = false;
-    bool shouldHaveVerticalScrollbar = false;
-    computeScrollbarExistence(shouldHaveHorizontalScrollbar, shouldHaveVerticalScrollbar, documentRect.size());
-
-    bool hasHorizontalScrollbar = horizontalScrollbar();
-    bool hasVerticalScrollbar = verticalScrollbar();
-    if (hasHorizontalScrollbar != shouldHaveHorizontalScrollbar
-        || hasVerticalScrollbar != shouldHaveVerticalScrollbar) {
-        setNeedsLayout();
-        return;
-    }
-
     adjustViewSize();
-    updateScrollbarGeometry();
 }
 
 bool FrameView::usesCompositedScrolling() const
 {
     RenderView* renderView = this->renderView();
     if (!renderView)
         return false;
     if (m_frame->settings() && m_frame->settings()->preferCompositingToLCDTextEnabled())
         return renderView->compositor()->inCompositingMode();
     return false;
@@ skipping 24 matching lines @@
 }
 
 GraphicsLayer* FrameView::layerForScrollCorner() const
 {
     RenderView* renderView = this->renderView();
     if (!renderView)
         return 0;
     return renderView->compositor()->layerForScrollCorner();
 }
 
+IntRect FrameView::contentsToScreen(const IntRect& rect) const
+{
+    HostWindow* window = hostWindow();
+    if (!window)
+        return IntRect();
+    return window->rootViewToScreen(contentsToRootView(rect));
+}
+
+bool FrameView::scheduleAnimation()
+{
+    if (HostWindow* window = hostWindow()) {
+        window->scheduleAnimation();
+        return true;
+    }
+    return false;
+}
+
 bool FrameView::isEnclosedInCompositingLayer() const
 {
     return false;
 }
 
 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const
 {
     return onlyDuringLayout && layoutPending() ? 0 : m_layoutSubtreeRoot;
 }
 
@@ skipping 127 matching lines @@
         return;
     }
 
     FontCachePurgePreventer fontCachePurgePreventer;
     RenderLayer* layer;
     {
         TemporaryChange<bool> changeSchedulingEnabled(m_layoutSchedulingEnabled, false);
 
         m_nestedLayoutCount++;
 
-        ScrollbarMode hMode;
-        ScrollbarMode vMode;
-        calculateScrollbarModesForLayoutAndSetViewportRenderer(hMode, vMode);
-
         if (!inSubtreeLayout) {
-            // Now set our scrollbar state for the layout.
-            ScrollbarMode currentHMode = horizontalScrollbarMode();
-            ScrollbarMode currentVMode = verticalScrollbarMode();
-
             if (m_firstLayout) {
-                setScrollbarsSuppressed(true);
-
                 m_doFullPaintInvalidation = true;
                 m_firstLayout = false;
                 m_firstLayoutCallbackPending = true;
                 m_lastViewportSize = layoutSize(IncludeScrollbars);
                 m_lastZoomFactor = rootForThisLayout->style()->zoom();
-
-                // Set the initial vMode to AlwaysOn if we're auto.
-                if (vMode == ScrollbarAuto)
-                    setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
-                // Set the initial hMode to AlwaysOff if we're auto.
-                if (hMode == ScrollbarAuto)
-                    setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
-
-                setScrollbarModes(hMode, vMode);
-                setScrollbarsSuppressed(false, true);
-            } else if (hMode != currentHMode || vMode != currentVMode) {
-                setScrollbarModes(hMode, vMode);
             }
 
             m_size = LayoutSize(layoutSize().width(), layoutSize().height());
 
             // We need to set m_doFullPaintInvalidation before triggering layout as RenderObject::checkForPaintInvalidation
             // checks the boolean to disable local paint invalidations.
             m_doFullPaintInvalidation |= renderView()->shouldDoFullPaintInvalidationForNextLayout();
         }
 
         layer = rootForThisLayout->enclosingLayer();
@@ skipping 14 matching lines @@
     layer->updateLayerPositionsAfterLayout();
 
     if (m_doFullPaintInvalidation)
         renderView()->compositor()->fullyInvalidatePaint();
     renderView()->compositor()->didLayout();
 
     m_layoutCount++;
 
     ASSERT(!rootForThisLayout->needsLayout());
 
-    if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
-        updateOverflowStatus(layoutSize().width() < contentsWidth(), layoutSize().height() < contentsHeight());
+    if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER)) {
+        updateOverflowStatus(layoutSize().width() < width(),
+            layoutSize().height() < height());
+    }
 
     scheduleOrPerformPostLayoutTasks();
 
     TRACE_EVENT_END1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Layout", "endData", InspectorLayoutEvent::endData(rootForThisLayout));
 
     m_nestedLayoutCount--;
     if (m_nestedLayoutCount)
         return;
 
 #if ENABLE(ASSERT)
@@ skipping 20 matching lines @@
     ASSERT(renderView());
     RenderView& rootForPaintInvalidation = *renderView();
     ASSERT(!rootForPaintInvalidation.needsLayout());
 
     TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", rootForPaintInvalidation.debugName().ascii());
 
     PaintInvalidationState rootPaintInvalidationState(rootForPaintInvalidation);
 
     rootForPaintInvalidation.invalidateTreeIfNeeded(rootPaintInvalidationState);
 
-    // Invalidate the paint of the frameviews scrollbars if needed
-    if (hasVerticalBarDamage())
-        invalidateRect(verticalBarDamage());
-    if (hasHorizontalBarDamage())
-        invalidateRect(horizontalBarDamage());
-    resetScrollbarDamage();
-
     m_doFullPaintInvalidation = false;
 #ifndef NDEBUG
     renderView()->assertSubtreeClearedPaintInvalidationState();
 #endif
 
     if (m_frame->selection().isCaretBoundsDirty())
         m_frame->selection().invalidateCaretRect();
 }
 
 DocumentLifecycle& FrameView::lifecycle() const
@@ skipping 182 matching lines @@
 }
 
 bool FrameView::shouldSetCursor() const
 {
     Page* page = frame().page();
     return page && page->visibilityState() != PageVisibilityStateHidden && page->focusController().isActive() && page->settings().deviceSupportsMouse();
 }
 
 void FrameView::scrollContentsIfNeededRecursive()
 {
-    scrollContentsIfNeeded();
+    // FIXME(sky): Remove
 }
 
 void FrameView::scrollContentsIfNeeded()
 {
-    bool didScroll = !pendingScrollDelta().isZero();
-    ScrollView::scrollContentsIfNeeded();
-    if (didScroll)
-        updateFixedElementPaintInvalidationRectsAfterScroll();
+    // FIXME(sky): Remove
 }
 
 bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta)
 {
     if (!contentsInCompositedLayer() || hasSlowRepaintObjects())
         return false;
 
     if (!m_viewportConstrainedObjects || m_viewportConstrainedObjects->isEmpty())
         return true;
 
@@ skipping 43 matching lines @@
         updateRect.unite(scrolledRect);
         // FIXME: We should be able to issue these invalidations separately and before we actually scroll.
         renderView()->layer()->paintInvalidator().setBackingNeedsPaintInvalidationInRect(rootViewToContents(updateRect));
     }
 
     return true;
 }
 
 void FrameView::scrollContentsSlowPath(const IntRect& updateRect)
 {
-    if (contentsInCompositedLayer()) {
-        IntRect updateRect = visibleContentRect();
-        ASSERT(renderView());
-        renderView()->layer()->paintInvalidator().setBackingNeedsPaintInvalidationInRect(updateRect);
-    }
-    ScrollView::scrollContentsSlowPath(updateRect);
+    // FIXME(sky): Remove
 }
 
 void FrameView::restoreScrollbar()
 {
-    setScrollbarsSuppressed(false);
+    // FIXME(sky): Remove
 }
 
 void FrameView::scrollElementToRect(Element* element, const IntRect& rect)
 {
     // FIXME(http://crbug.com/371896) - This method shouldn't be manually doing
     // coordinate transformations to the PinchViewport.
     IntRect targetRect(rect);
 
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
@@ skipping 18 matching lines @@
     setScrollPosition(targetOffset);
 
     if (pinchVirtualViewportEnabled) {
         IntPoint remainder = IntPoint(targetOffset - scrollPosition());
         m_frame->page()->frameHost().pinchViewport().move(remainder);
     }
 }
 
 void FrameView::setScrollPosition(const IntPoint& scrollPoint, ScrollBehavior scrollBehavior)
 {
-    cancelProgrammaticScrollAnimation();
-    TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, true);
-
-    IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint);
-
-    if (newScrollPosition == scrollPosition())
-        return;
-
-    if (scrollBehavior == ScrollBehaviorAuto) {
-        RenderObject* renderer = m_frame->document()->documentElement() ? m_frame->document()->documentElement()->renderer() : 0;
-        if (renderer)
-            scrollBehavior = renderer->style()->scrollBehavior();
-        else
-            scrollBehavior = ScrollBehaviorInstant;
-    }
-    ScrollView::setScrollPosition(newScrollPosition, scrollBehavior);
+    // FIXME(sky): Remove
 }
 
-void FrameView::setScrollPositionNonProgrammatically(const IntPoint& scrollPoint)
+void FrameView::setScrollPositionNonProgrammatically(const IntPoint&)
 {
-    IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint);
-
-    if (newScrollPosition == scrollPosition())
-        return;
-
-    TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, false);
-    notifyScrollPositionChanged(newScrollPosition);
+    // FIXME(sky): Remove
 }
 
-IntSize FrameView::layoutSize(IncludeScrollbarsInRect scrollbarInclusion) const
+// FIXME(sky): remove
+IntSize FrameView::layoutSize(IncludeScrollbarsInRect) const
 {
-    return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(m_layoutSize) : m_layoutSize;
+    return m_layoutSize;
 }
 
 void FrameView::setLayoutSize(const IntSize& size)
 {
     ASSERT(!layoutSizeFixedToFrameSize());
 
     setLayoutSizeInternal(size);
 }
 
 void FrameView::scrollPositionChanged()
@@ skipping 78 matching lines @@
     if (!frame || !frame->selection().isCaretOrRange()) {
         page->chrome().client().clearCompositedSelectionBounds();
         return;
     }
 
     // TODO(jdduke): Compute and route selection bounds through ChromeClient.
 }
 
 bool FrameView::isRubberBandInProgress() const
 {
-    if (scrollbarsSuppressed())
-        return false;
-
-    // If the main thread updates the scroll position for this FrameView, we should return
-    // ScrollAnimator::isRubberBandInProgress().
-    if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
-        return scrollAnimator->isRubberBandInProgress();
-
+    // FIXME(sky): Remove
     return false;
 }
 
 HostWindow* FrameView::hostWindow() const
 {
     Page* page = frame().page();
     if (!page)
         return 0;
     return &page->chrome();
 }
 
 void FrameView::contentRectangleForPaintInvalidation(const IntRect& r)
 {
     ASSERT(paintInvalidationIsAllowed());
 
     if (m_isTrackingPaintInvalidations) {
         IntRect paintInvalidationRect = r;
         paintInvalidationRect.move(-scrollOffset());
         m_trackedPaintInvalidationRects.append(paintInvalidationRect);
         // FIXME: http://crbug.com/368518. Eventually, invalidateContentRectangleForPaint
         // is going away entirely once all layout tests are FCM. In the short
         // term, no code should be tracking non-composited FrameView paint invalidations.
         RELEASE_ASSERT_NOT_REACHED();
     }
 
-    ScrollView::contentRectangleForPaintInvalidation(r);
+    IntRect paintRect = r;
+    if (clipsPaintInvalidations() && !paintsEntireContents())
+        paintRect.intersect(visibleContentRect());
+    if (paintRect.isEmpty())
+        return;
+
+    if (HostWindow* window = hostWindow())
+        window->invalidateContentsAndRootView(contentsToWindow(paintRect));
 }
 
 void FrameView::contentsResized()
 {
-    ScrollView::contentsResized();
     setNeedsLayout();
 }
 
 void FrameView::scrollbarExistenceDidChange()
 {
     // We check to make sure the view is attached to a frame() as this method can
     // be triggered before the view is attached by LocalFrame::createView(...) setting
     // various values such as setScrollBarModes(...) for example.  An ASSERT is
     // triggered when a view is layout before being attached to a frame().
     if (!frame().view())
@@ skipping 247 matching lines @@
         m_overflowStatusDirty = false;
         return;
     }
 }
 
 IntRect FrameView::windowClipRect(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     ASSERT(m_frame->view() == this);
 
     if (paintsEntireContents())
-        return IntRect(IntPoint(), contentsSize());
+        return IntRect(IntPoint(), size());
 
     // Set our clip rect to be our contents.
     IntRect clipRect = contentsToWindow(visibleContentRect(scrollbarInclusion));
     return clipRect;
 }
 
 bool FrameView::isActive() const
 {
     Page* page = frame().page();
     return page && page->focusController().isActive();
 }
 
 void FrameView::scrollTo(const IntSize& newOffset)
 {
-    LayoutSize offset = scrollOffset();
-    ScrollView::scrollTo(newOffset);
-    if (offset != scrollOffset()) {
-        updateLayersAndCompositingAfterScrollIfNeeded();
-        scrollPositionChanged();
-    }
-    frame().loaderClient()->didChangeScrollOffset();
+    // FIXME(sky): remove
 }
 
-void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
+void FrameView::invalidateScrollbarRect(Scrollbar*, const IntRect&)
 {
-    // Add in our offset within the FrameView.
-    IntRect dirtyRect = rect;
-    dirtyRect.moveBy(scrollbar->location());
-
-    if (isInPerformLayout())
-        addScrollbarDamage(scrollbar, rect);
-    else
-        invalidateRect(dirtyRect);
+    // FIXME(sky): remove
 }
 
 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
 {
     if (!m_tickmarks.isEmpty())
         tickmarks = m_tickmarks;
     else
         tickmarks = frame().document()->markers().renderedRectsForMarkers(DocumentMarker::TextMatch);
 }
 
 void FrameView::setVisibleContentScaleFactor(float visibleContentScaleFactor)
 {
     if (m_visibleContentScaleFactor == visibleContentScaleFactor)
         return;
-
     m_visibleContentScaleFactor = visibleContentScaleFactor;
-    updateScrollbars(scrollOffset());
 }
 
 void FrameView::setInputEventsTransformForEmulation(const IntSize& offset, float contentScaleFactor)
 {
     m_inputEventsOffsetForEmulation = offset;
     m_inputEventsScaleFactorForEmulation = contentScaleFactor;
 }
 
 IntSize FrameView::inputEventsOffsetForEmulation() const
 {
@@ skipping 16 matching lines @@
     return !!m_frame->document();
 }
 
 IntRect FrameView::scrollableAreaBoundingBox() const
 {
     return frameRect();
 }
 
 bool FrameView::isScrollable()
 {
-    // Check for:
-    // 1) If there an actual overflow.
-    // 2) display:none or visibility:hidden set to self or inherited.
-    // 3) overflow{-x,-y}: hidden;
-    // 4) scrolling: no;
-
-    // Covers #1
-    IntSize contentsSize = this->contentsSize();
-    IntSize visibleContentSize = visibleContentRect().size();
-    if ((contentsSize.height() <= visibleContentSize.height() && contentsSize.width() <= visibleContentSize.width()))
-        return false;
-
-
-    // Cover #3 and #4.
-    ScrollbarMode horizontalMode;
-    ScrollbarMode verticalMode;
-    calculateScrollbarModesForLayoutAndSetViewportRenderer(horizontalMode, verticalMode, RulesFromWebContentOnly);
-    if (horizontalMode == ScrollbarAlwaysOff && verticalMode == ScrollbarAlwaysOff)
-        return false;
-
-    return true;
+    // FIXME(sky): Remove
+    return false;
 }
 
 void FrameView::notifyPageThatContentAreaWillPaint() const
 {
     Page* page = m_frame->page();
     if (!page)
         return;
 
-    contentAreaWillPaint();
-
     if (!m_scrollableAreas)
         return;
 
     for (HashSet<ScrollableArea*>::const_iterator it = m_scrollableAreas->begin(), end = m_scrollableAreas->end(); it != end; ++it) {
         ScrollableArea* scrollableArea = *it;
 
         if (!scrollableArea->scrollbarsCanBeActive())
             continue;
 
         scrollableArea->contentAreaWillPaint();
@@ skipping 130 matching lines @@
 
 void FrameView::setNodeToDraw(Node* node)
 {
     m_nodeToDraw = node;
 }
 
 void FrameView::paintOverhangAreas(GraphicsContext* context, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect)
 {
     if (m_frame->page()->chrome().client().paintCustomOverhangArea(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect))
         return;
-
-    ScrollView::paintOverhangAreas(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect);
 }
 
 void FrameView::updateWidgetPositionsIfNeeded()
 {
     if (!m_needsUpdateWidgetPositions)
         return;
 
     m_needsUpdateWidgetPositions = false;
 
     updateWidgetPositions();
@@ skipping 184 matching lines @@
     m_scrollableAreas->add(scrollableArea);
 }
 
 void FrameView::removeScrollableArea(ScrollableArea* scrollableArea)
 {
     if (!m_scrollableAreas)
         return;
     m_scrollableAreas->remove(scrollableArea);
 }
 
+void FrameView::addChild(PassRefPtr<Widget> prpChild)
+{
+    Widget* child = prpChild.get();
+    ASSERT(child != this && !child->parent());
+    child->setParent(this);
+    m_children.add(prpChild);
+}
+
 void FrameView::removeChild(Widget* widget)
 {
-    if (widget->isFrameView())
-        removeScrollableArea(toFrameView(widget));
-
-    ScrollView::removeChild(widget);
+    ASSERT(widget->parent() == this);
+    widget->setParent(0);
+    m_children.remove(widget);
 }
 
 bool FrameView::wheelEvent(const PlatformWheelEvent& wheelEvent)
 {
-    bool allowScrolling = userInputScrollable(HorizontalScrollbar) || userInputScrollable(VerticalScrollbar);
-
-    if (!isScrollable())
-        allowScrolling = false;
-
-    if (allowScrolling && ScrollableArea::handleWheelEvent(wheelEvent))
-        return true;
-
-    // If the frame didn't handle the event, give the pinch-zoom viewport a chance to
-    // process the scroll event.
-    if (m_frame->settings()->pinchVirtualViewportEnabled())
-        return page()->frameHost().pinchViewport().handleWheelEvent(wheelEvent);
-
+    // FIXME(sky): Remove
     return false;
 }
 
 bool FrameView::isVerticalDocument() const
 {
     RenderView* renderView = this->renderView();
     if (!renderView)
         return true;
 
     return renderView->style()->isHorizontalWritingMode();
@@ skipping 14 matching lines @@
     if (!page || !page->settings().deviceSupportsMouse())
         return;
     page->chrome().setCursor(cursor);
 }
 
 void FrameView::frameRectsChanged()
 {
     if (layoutSizeFixedToFrameSize())
         setLayoutSizeInternal(frameRect().size());
 
-    ScrollView::frameRectsChanged();
+    HashSet<RefPtr<Widget> >::const_iterator end = m_children.end();
+    for (HashSet<RefPtr<Widget> >::const_iterator current = m_children.begin();
+            current != end; ++current) {

[abarth-chromium, 2014/10/24 03:16:06]

for (const auto& widget : m_children) {
  ...
}

For realz

[ojan, 2014/10/24 03:21:01]

Amazing. Done.

I guess it's time to actually learn C++11 syntax!

+        (*current)->frameRectsChanged();
+    }
 }
 
 void FrameView::setLayoutSizeInternal(const IntSize& size)
 {
     if (m_layoutSize == size)
         return;
 
     m_layoutSize = size;
     contentsResized();
 }
 
 } // namespace blink