Revert of Clip scrollbars to box bounds when they don't fit.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.h

 /*
  * Copyright (C) 2009, 2010, 2011 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 93 matching lines @@
     GraphicsLayer* scrollingBlockSelectionLayer() const { return m_scrollingBlockSelectionLayer.get(); }
 
     bool hasMaskLayer() const { return m_maskLayer; }
     GraphicsLayer* maskLayer() const { return m_maskLayer.get(); }
 
     bool hasChildClippingMaskLayer() const { return m_childClippingMaskLayer; }
     GraphicsLayer* childClippingMaskLayer() const { return m_childClippingMaskLayer.get(); }
 
     GraphicsLayer* parentForSublayers() const;
     GraphicsLayer* childForSuperlayers() const;
-    void setSublayers(const GraphicsLayerVector&);
 
     bool hasChildTransformLayer() const { return m_childTransformLayer; }
     GraphicsLayer* childTransformLayer() const { return m_childTransformLayer.get(); }
 
     GraphicsLayer* squashingContainmentLayer() const { return m_squashingContainmentLayer.get(); }
     GraphicsLayer* squashingLayer() const { return m_squashingLayer.get(); }
 
     void setSquashingContentsNeedDisplay();
     void setContentsNeedDisplay();
     // LayoutRect is in the coordinate space of the layer's layout object.
@@ skipping 198 matching lines @@
     PaintLayer& m_owningLayer;
 
     // The hierarchy of layers that is maintained by the CompositedLayerMapping looks like this:
     //
     //  + m_ancestorClippingLayer [OPTIONAL]
     //    + m_graphicsLayer
     //      + m_childTransformLayer [OPTIONAL]
     //      | + m_childContainmentLayer [OPTIONAL] <-OR-> m_scrollingLayer [OPTIONAL]
     //      |                                             + m_scrollingContentsLayer [Present iff m_scrollingLayer is present]
     //      |                                               + m_scrollingBlockSelectionLayer [Present iff m_scrollingLayer is present]
-    //      + m_overflowControlsAncestorClippingLayer [OPTIONAL] // *The overflow controls may need to be repositioned in the
-    //        + m_overflowControlsHostLayer [OPTIONAL]           //  graphics layer tree by the RLC to ensure that they stack
-    //          + m_layerForVerticalScrollbar [OPTIONAL]         //  above scrolling content.
+    //      + m_overflowControlsClippingLayer [OPTIONAL] // *The overflow controls may need to be repositioned in the
+    //        + m_overflowControlsHostLayer [OPTIONAL]   //  graphics layer tree by the RLC to ensure that they stack
+    //          + m_layerForVerticalScrollbar [OPTIONAL] //  above scrolling content.
     //          + m_layerForHorizontalScrollbar [OPTIONAL]
     //          + m_layerForScrollCorner [OPTIONAL]
     //
     // We need an ancestor clipping layer if our clipping ancestor is not our ancestor in the
     // clipping tree. Here's what that might look like.
     //
     // Let A = the clipping ancestor,
     //     B = the clip descendant, and
     //     SC = the stacking context that is the ancestor of A and B in the stacking tree.
     //
@@ skipping 46 matching lines @@
     //
     // With the hierarchy set up like this, the root content layer is able to scroll without affecting
     // the background layer (or paint invalidation).
     OwnPtr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
     OwnPtr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
 
     OwnPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
     OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
 
-    // This layer contains the scrollbar and scroll corner layers and clips them to the border box
-    // bounds of our LayoutObject. It is usually added to m_graphicsLayer, but may be reparented by
-    // GraphicsLayerTreeBuilder to ensure that scrollbars appear above scrolling content.
+    // This layer exists to simplify the reparenting of overflow control that is occasionally required
+    // to ensure that scrollbars appear above scrolling content.
     OwnPtr<GraphicsLayer> m_overflowControlsHostLayer;
 
     // The reparented overflow controls sometimes need to be clipped by a non-ancestor. In just the same
     // way we need an ancestor clipping layer to clip this CLM's internal hierarchy, we add another layer
-    // to clip the overflow controls. We could combine this with m_overflowControlsHostLayer, but that
-    // would require manually intersecting their clips, and shifting the overflow controls to compensate
-    // for this clip's offset. By using a separate layer, the overflow controls can remain ignorant of
-    // ancestor clipping.
-    OwnPtr<GraphicsLayer> m_overflowControlsAncestorClippingLayer;
+    // to clip the overflow controls. It would be possible to make m_overflowControlsHostLayer be
+    // responsible for applying this clip, but that could require repositioning all of the overflow
+    // controls since the this clip may apply an offset. By using a separate layer, the overflow controls
+    // can remain ignorant of the layers above them and still work correctly.
+    OwnPtr<GraphicsLayer> m_overflowControlsClippingLayer;
 
     // A squashing CLM has two possible squashing-related structures.
     //
     // If m_ancestorClippingLayer is present:
     //
     // m_ancestorClippingLayer
     //   + m_graphicsLayer
     //   + m_squashingLayer
     //
     // If not:
@@ skipping 19 matching lines @@
 
     unsigned m_backgroundLayerPaintsFixedRootBackground : 1;
     unsigned m_scrollingContentsAreEmpty : 1;
 
     friend class CompositedLayerMappingTest;
 };
 
 } // namespace blink
 
 #endif // CompositedLayerMapping_h