Some minor cleanup to RenderLayerClipper.

sky/engine/core/rendering/RenderLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 31 matching lines @@
  */
 
 #include "sky/engine/config.h"
 #include "sky/engine/core/rendering/RenderLayerClipper.h"
 
 #include "sky/engine/core/rendering/RenderLayer.h"
 #include "sky/engine/core/rendering/RenderView.h"
 
 namespace blink {
 
-static void adjustClipRectsForChildren(const RenderObject& renderer, ClipRects& clipRects)
-{
-    if (renderer.style()->position() == AbsolutePosition) {
-        clipRects.setOverflowClipRect(clipRects.posClipRect());
-    }
-}
-
-static void applyClipRects(const ClipRectsContext& context, RenderObject& renderer, LayoutPoint offset, ClipRects& clipRects)
-{
-    ASSERT(renderer.hasOverflowClip() || renderer.hasClip());
-
-    if (renderer.hasOverflowClip()) {
-        ClipRect newOverflowClip = toRenderBox(renderer).overflowClipRect(offset);
-        newOverflowClip.setHasRadius(renderer.style()->hasBorderRadius());
-        clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
-        if (renderer.isPositioned())
-            clipRects.setPosClipRect(intersection(newOverflowClip, clipRects.posClipRect()));
-    }
-
-    if (renderer.hasClip()) {
-        LayoutRect newClip = toRenderBox(renderer).clipRect(offset);
-        clipRects.setPosClipRect(intersection(newClip, clipRects.posClipRect()));
-        clipRects.setOverflowClipRect(intersection(newClip, clipRects.overflowClipRect()));
-    }
-}
-
 RenderLayerClipper::RenderLayerClipper(RenderBox& renderer)
     : m_renderer(renderer)
 {
 }
 
 ClipRects* RenderLayerClipper::clipRectsIfCached(const ClipRectsContext& context) const
 {
     ASSERT(context.usesCache());
     if (!m_cache)
         return 0;
@@ skipping 154 matching lines @@
         // FIXME: Why don't we just call getClipRects here?
         if (context.usesCache() && parentLayer->clipper().cachedClipRects(context)) {
             clipRects = *parentLayer->clipper().cachedClipRects(context);
         } else {
             parentLayer->clipper().calculateClipRects(context, clipRects);
         }
     } else {
         clipRects.reset(PaintInfo::infiniteRect());
     }
 
-    adjustClipRectsForChildren(m_renderer, clipRects);
+    if (m_renderer.style()->position() == AbsolutePosition) {
+        clipRects.setOverflowClipRect(clipRects.posClipRect());
+    }
 
+    // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
+    // some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where
+    // clipRects are needed in view space.
+    LayoutPoint offset = roundedLayoutPoint(m_renderer.localToContainerPoint(FloatPoint(), context.rootLayer->renderer()));
     if (m_renderer.hasOverflowClip()) {
-        // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
-        // some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where
-        // clipRects are needed in view space.
-        applyClipRects(context, m_renderer, roundedLayoutPoint(m_renderer.localToContainerPoint(FloatPoint(), context.rootLayer->renderer())), clipRects);
+        ClipRect newOverflowClip = m_renderer.overflowClipRect(offset);
+        newOverflowClip.setHasRadius(m_renderer.style()->hasBorderRadius());
+        clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
+        if (m_renderer.isPositioned())
+            clipRects.setPosClipRect(intersection(newOverflowClip, clipRects.posClipRect()));
+    }
+
+    if (m_renderer.hasClip()) {
+        LayoutRect newClip = m_renderer.clipRect(offset);
+        clipRects.setPosClipRect(intersection(newClip, clipRects.posClipRect()));
+        clipRects.setOverflowClipRect(intersection(newClip, clipRects.overflowClipRect()));
     }
 }
 
-static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects, EPosition position)
-{
-    if (position == AbsolutePosition)
-        return parentRects.posClipRect();
-    return parentRects.overflowClipRect();
-}
-
 ClipRect RenderLayerClipper::backgroundClipRect(const ClipRectsContext& context) const
 {
     ASSERT(m_renderer.layer()->parent());
     ASSERT(m_renderer.view());
 
     ClipRects parentClipRects;
     if (m_renderer.layer() == context.rootLayer)
         parentClipRects.reset(PaintInfo::infiniteRect());
     else
         m_renderer.layer()->parent()->clipper().getOrCalculateClipRects(context, parentClipRects);
 
-    return backgroundClipRectForPosition(parentClipRects, m_renderer.style()->position());
+    if (m_renderer.style()->position() == AbsolutePosition)
+        return parentClipRects.posClipRect();
+    return parentClipRects.overflowClipRect();
 }
 
 void RenderLayerClipper::getOrCalculateClipRects(const ClipRectsContext& context, ClipRects& clipRects) const
 {
     if (context.usesCache())
         clipRects = *getClipRects(context);
     else
         calculateClipRects(context, clipRects);
 }
 
 RenderLayer* RenderLayerClipper::clippingRootForPainting() const
 {
     const RenderLayer* current = m_renderer.layer();
     while (current) {
         if (current->isRootLayer())
             return const_cast<RenderLayer*>(current);
 
         current = current->compositingContainer();
         ASSERT(current);
         if (current->renderer()->transform())
             return const_cast<RenderLayer*>(current);
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 } // namespace blink