Removed ScrollingCoordinator and a bunch of composited scrolling'

sky/engine/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 17 matching lines @@
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 
 #include "core/animation/DocumentAnimations.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/inspector/InspectorNodeIds.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
-#include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/rendering/RenderLayerStackingNode.h"
 #include "core/rendering/RenderLayerStackingNodeIterator.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/CompositedLayerMapping.h"
 #include "core/rendering/compositing/CompositingInputsUpdater.h"
 #include "core/rendering/compositing/CompositingLayerAssigner.h"
 #include "core/rendering/compositing/CompositingRequirementsUpdater.h"
 #include "core/rendering/compositing/GraphicsLayerTreeBuilder.h"
 #include "core/rendering/compositing/GraphicsLayerUpdater.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 309 matching lines @@
 {
     if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->setPosition(contentsOffset);
 }
 
 void RenderLayerCompositor::frameViewDidChangeSize()
 {
     if (m_containerLayer) {
         FrameView* frameView = m_renderView.frameView();
         m_containerLayer->setSize(frameView->unscaledVisibleContentSize());
-        updateOverflowControlsLayers();
     }
 }
 
 void RenderLayerCompositor::rootFixedBackgroundsChanged()
 {
     if (!supportsFixedRootBackgroundCompositing())
         return;
 
     // To avoid having to make the fixed root background layer fixed positioned to
     // stay put, we position it in the layer tree as follows:
     //
     // + Overflow controls host
     //   + LocalFrame clip
     //     + (Fixed root background) <-- Here.
     //     + LocalFrame scroll
     //       + Root content layer
     //   + Scrollbars
     //
     // That is, it needs to be the first child of the frame clip, the sibling of
     // the frame scroll layer. The compositor does not own the background layer, it
     // just positions it (like the foreground layer).
     if (GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer())
         m_containerLayer->addChildBelow(backgroundLayer, m_scrollLayer.get());
 }
 
-bool RenderLayerCompositor::scrollingLayerDidChange(RenderLayer* layer)
-{
-    if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
-        return scrollingCoordinator->scrollableAreaScrollLayerDidChange(layer->scrollableArea());
-    return false;
-}
-
 String RenderLayerCompositor::layerTreeAsText(LayerTreeFlags flags)
 {
     ASSERT(lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean);
 
     if (!m_rootContentLayer)
         return String();
 
     // We skip dumping the scroll and clip layers to keep layerTreeAsText output
     // similar between platforms (unless we explicitly request dumping from the
     // root.
@@ skipping 53 matching lines @@
 }
 
 GraphicsLayer* RenderLayerCompositor::ensureRootTransformLayer()
 {
     ASSERT(rootGraphicsLayer());
 
     if (!m_rootTransformLayer.get()) {
         m_rootTransformLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
         m_overflowControlsHostLayer->addChild(m_rootTransformLayer.get());
         m_rootTransformLayer->addChild(m_containerLayer.get());
-        updateOverflowControlsLayers();
     }
 
     return m_rootTransformLayer.get();
 }
 
 void RenderLayerCompositor::setIsInWindow(bool isInWindow)
 {
     if (!staleInCompositingMode())
         return;
 
@@ skipping 125 matching lines @@
 {
     ASSERT(lifecycle().state() == DocumentLifecycle::PaintInvalidationClean);
     m_isTrackingPaintInvalidations = tracksPaintInvalidations;
 }
 
 bool RenderLayerCompositor::isTrackingPaintInvalidations() const
 {
     return m_isTrackingPaintInvalidations;
 }
 
-bool RenderLayerCompositor::requiresHorizontalScrollbarLayer() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
-bool RenderLayerCompositor::requiresVerticalScrollbarLayer() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
-void RenderLayerCompositor::updateOverflowControlsLayers()
-{
-    GraphicsLayer* controlsParent = m_rootTransformLayer.get() ? m_rootTransformLayer.get() : m_overflowControlsHostLayer.get();
-
-    if (requiresHorizontalScrollbarLayer()) {
-        if (!m_layerForHorizontalScrollbar) {
-            m_layerForHorizontalScrollbar = GraphicsLayer::create(graphicsLayerFactory(), this);
-        }
-
-        if (m_layerForHorizontalScrollbar->parent() != controlsParent) {
-            controlsParent->addChild(m_layerForHorizontalScrollbar.get());
-        }
-    } else if (m_layerForHorizontalScrollbar) {
-        m_layerForHorizontalScrollbar->removeFromParent();
-        m_layerForHorizontalScrollbar = nullptr;
-    }
-
-    if (requiresVerticalScrollbarLayer()) {
-        if (!m_layerForVerticalScrollbar) {
-            m_layerForVerticalScrollbar = GraphicsLayer::create(graphicsLayerFactory(), this);
-        }
-
-        if (m_layerForVerticalScrollbar->parent() != controlsParent) {
-            controlsParent->addChild(m_layerForVerticalScrollbar.get());
-        }
-    } else if (m_layerForVerticalScrollbar) {
-        m_layerForVerticalScrollbar->removeFromParent();
-        m_layerForVerticalScrollbar = nullptr;
-    }
-}
-
 void RenderLayerCompositor::ensureRootLayer()
 {
     RootLayerAttachment expectedAttachment = RootLayerAttachedViaChromeClient;
     if (expectedAttachment == m_rootLayerAttachment)
          return;
 
     if (!m_rootContentLayer) {
         m_rootContentLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
         IntRect overflowRect = m_renderView.pixelSnappedLayoutOverflowRect();
         m_rootContentLayer->setSize(FloatSize(overflowRect.maxX(), overflowRect.maxY()));
@@ skipping 37 matching lines @@
     attachRootLayer(expectedAttachment);
 }
 
 void RenderLayerCompositor::destroyRootLayer()
 {
     if (!m_rootContentLayer)
         return;
 
     detachRootLayer();
 
-    if (m_layerForHorizontalScrollbar) {
-        m_layerForHorizontalScrollbar->removeFromParent();
-        m_layerForHorizontalScrollbar = nullptr;
-    }
-
-    if (m_layerForVerticalScrollbar) {
-        m_layerForVerticalScrollbar->removeFromParent();
-        m_layerForVerticalScrollbar = nullptr;
-    }
-
     if (m_overflowControlsHostLayer) {
         m_overflowControlsHostLayer = nullptr;
         m_containerLayer = nullptr;
         m_scrollLayer = nullptr;
     }
     ASSERT(!m_scrollLayer);
     m_rootContentLayer = nullptr;
     m_rootTransformLayer = nullptr;
 }
 
@@ skipping 44 matching lines @@
     }
 
     m_rootLayerAttachment = RootLayerUnattached;
 }
 
 void RenderLayerCompositor::updateRootLayerAttachment()
 {
     ensureRootLayer();
 }
 
-ScrollingCoordinator* RenderLayerCompositor::scrollingCoordinator() const
-{
-    if (Page* page = this->page())
-        return page->scrollingCoordinator();
-
-    return 0;
-}
-
 GraphicsLayerFactory* RenderLayerCompositor::graphicsLayerFactory() const
 {
     if (Page* page = this->page())
         return page->chrome().client().graphicsLayerFactory();
     return 0;
 }
 
 Page* RenderLayerCompositor::page() const
 {
     return m_renderView.frameView()->frame().page();
 }
 
 DocumentLifecycle& RenderLayerCompositor::lifecycle() const
 {
     return m_renderView.document().lifecycle();
 }
 
 String RenderLayerCompositor::debugName(const GraphicsLayer* graphicsLayer)
 {
     String name;
     if (graphicsLayer == m_rootContentLayer.get()) {
         name = "Content Root Layer";
     } else if (graphicsLayer == m_rootTransformLayer.get()) {
         name = "Root Transform Layer";
     } else if (graphicsLayer == m_overflowControlsHostLayer.get()) {
         name = "Overflow Controls Host Layer";
-    } else if (graphicsLayer == m_layerForHorizontalScrollbar.get()) {
-        name = "Horizontal Scrollbar Layer";
-    } else if (graphicsLayer == m_layerForVerticalScrollbar.get()) {
-        name = "Vertical Scrollbar Layer";
     } else if (graphicsLayer == m_containerLayer.get()) {
         name = "LocalFrame Clipping Layer";
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink