Rewrite scrollable layers using multiple layers.

Remove PlatformBridge::updateLayers and instead call layersDraw from
ChromeClientAndroid during a requested sync.

Instead of LayerAndroid having knowledge of scrolling pictures, use multiple
layers (background, mask, foreground).

Update navigation to use the new structure.  Always record nodes in absolute,
unscrolled coordinates.  Do not track layers unless the node has a composited
layer and a last child.  Check for composited parents when adding to tracked
layers as well.

TODO:
* developer.android.com doesn't completely work with navigation due to some
  nodes being clipped out.
* BaseLayerAndroid needs to be able to operate with a matrix other than
  identity.
* nested fixed position elements do not draw correctly.
* nested overflow layers haven't been tested.

Change-Id: I0e2bd37612341e8884d68153ab36194cb2dc1eeb

5 files changed, 141 insertions, 161 deletions

diff --git a/WebCore/platform/graphics/android/BaseLayerAndroid.cpp b/WebCore/platform/graphics/android/BaseLayerAndroid.cpp
index f139eeb..996b272 100644
--- a/WebCore/platform/graphics/android/BaseLayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/BaseLayerAndroid.cpp
@@ -92,7 +92,10 @@ void BaseLayerAndroid::setContent(const PictureSet& src)
     android::Mutex::Autolock lock(m_drawLock);
 #endif
     m_content.set(src);
-    setSize(src.width(), src.height());
+    // FIXME: We cannot set the size of the base layer because it will screw up
+    // the matrix used.  We need to fix matrix computation for the base layer
+    // and then we can set the size.
+    // setSize(src.width(), src.height());
 }
 
 void BaseLayerAndroid::setExtra(SkPicture& src)
diff --git a/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp b/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
index 593c896..fe7b132 100644
--- a/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
@@ -120,7 +120,9 @@ GraphicsLayerAndroid::GraphicsLayerAndroid(GraphicsLayerClient* client) :
     m_translateY(0),
     m_currentTranslateX(0),
     m_currentTranslateY(0),
-    m_currentPosition(0, 0)
+    m_currentPosition(0, 0),
+    m_foregroundLayer(0),
+    m_foregroundClipLayer(0)
 {
     m_contentLayer = new LayerAndroid(true);
     RenderLayer* renderLayer = renderLayerFromClient(m_client);
@@ -134,6 +136,8 @@ GraphicsLayerAndroid::GraphicsLayerAndroid(GraphicsLayerClient* client) :
 GraphicsLayerAndroid::~GraphicsLayerAndroid()
 {
     m_contentLayer->unref();
+    SkSafeUnref(m_foregroundLayer);
+    SkSafeUnref(m_foregroundClipLayer);
     gDebugGraphicsLayerAndroidInstances--;
 }
 
@@ -162,8 +166,8 @@ bool GraphicsLayerAndroid::setChildren(const Vector<GraphicsLayer*>& children)
 void GraphicsLayerAndroid::addChild(GraphicsLayer* childLayer)
 {
 #ifndef NDEBUG
-    const char* n = (static_cast<GraphicsLayerAndroid*>(childLayer))->m_name.latin1().data();
-    LOG("(%x) addChild: %x (%s)", this, childLayer, n);
+    const String& name = childLayer->name();
+    LOG("(%x) addChild: %x (%s)", this, childLayer, name.latin1().data());
 #endif
     GraphicsLayer::addChild(childLayer);
     m_needsSyncChildren = true;
@@ -206,19 +210,11 @@ bool GraphicsLayerAndroid::replaceChild(GraphicsLayer* oldChild, GraphicsLayer*
 void GraphicsLayerAndroid::removeFromParent()
 {
     LOG("(%x) removeFromParent()", this);
-    if (m_parent)
-        static_cast<GraphicsLayerAndroid*>(m_parent)->needsSyncChildren();
     GraphicsLayer::removeFromParent();
     m_needsSyncChildren = true;
     askForSync();
 }
 
-void GraphicsLayerAndroid::needsSyncChildren()
-{
-    m_needsSyncChildren = true;
-    askForSync();
-}
-
 void GraphicsLayerAndroid::updateFixedPosition()
 {
     if (!m_client)
@@ -353,6 +349,19 @@ void GraphicsLayerAndroid::setDrawsContent(bool drawsContent)
     if (m_contentLayer->isRootLayer())
         return;
     if (m_drawsContent) {
+#if ENABLE(ANDROID_OVERFLOW_SCROLL)
+        RenderLayer* layer = renderLayerFromClient(m_client);
+        if (layer && layer->hasOverflowScroll() && !m_foregroundLayer) {
+            m_foregroundLayer = new LayerAndroid(false);
+            m_foregroundLayer->setContentScrollable(true);
+            m_foregroundClipLayer = new LayerAndroid(false);
+            m_foregroundClipLayer->setMasksToBounds(true);
+
+            m_foregroundClipLayer->addChild(m_foregroundLayer);
+            m_contentLayer->addChild(m_foregroundClipLayer);
+        }
+#endif
+
         m_haveContents = true;
         setNeedsDisplay();
     }
@@ -440,18 +449,42 @@ bool GraphicsLayerAndroid::repaint()
         // with SkPicture, we request the entire layer's content.
         IntRect layerBounds(0, 0, m_size.width(), m_size.height());
 
-        if (m_contentsRect.width() > m_size.width() ||
-                m_contentsRect.height() > m_size.height()) {
+        if (m_foregroundLayer) {
             PaintingPhase phase(this);
             // Paint the background into a separate context.
             phase.set(GraphicsLayerPaintBackground);
             if (!paintContext(m_contentLayer->recordContext(), layerBounds))
                 return false;
+
+            RenderLayer* layer = renderLayerFromClient(m_client);
+            // Construct the foreground layer and draw.
+            RenderBox* box = layer->renderBox();
+            int outline = box->view()->maximalOutlineSize();
+            IntRect contentsRect(0, 0,
+                                 box->borderLeft() + box->borderRight() + layer->scrollWidth(),
+                                 box->borderTop() + box->borderBottom() + layer->scrollHeight());
+            contentsRect.inflate(outline);
+            // Update the foreground layer size.
+            m_foregroundLayer->setSize(contentsRect.width(), contentsRect.height());
             // Paint everything else into the main recording canvas.
             phase.clear(GraphicsLayerPaintBackground);
-            if (!paintContext(m_contentLayer->foregroundContext(),
-                              m_contentsRect))
+            if (!paintContext(m_foregroundLayer->recordContext(), contentsRect))
                 return false;
+
+            // Construct the clip layer for masking the contents.
+            IntRect clip = layer->renderer()->absoluteBoundingBoxRect();
+            // absoluteBoundingBoxRect does not include the outline so we need
+            // to offset the position.
+            int x = box->borderLeft() + outline;
+            int y = box->borderTop() + outline;
+            int width = clip.width() - box->borderLeft() - box->borderRight();
+            int height = clip.height() - box->borderTop() - box->borderBottom();
+            m_foregroundClipLayer->setPosition(x, y);
+            m_foregroundClipLayer->setSize(width, height);
+
+            // Need to offset the foreground layer by the clip layer in order
+            // for the contents to be in the correct position.
+            m_foregroundLayer->setPosition(-x, -y);
         } else {
             // If there is no contents clip, we can draw everything into one
             // picture.
@@ -469,24 +502,6 @@ bool GraphicsLayerAndroid::repaint()
         m_needsRepaint = false;
         m_invalidatedRects.clear();
 
-        RenderLayer* layer = renderLayerFromClient(m_client);
-        // Use the absolute bounds of the renderer instead of the layer's
-        // bounds because the layer will add in the outline.  What we want
-        // is the content bounds inside the outline.
-        FloatRect clip = layer->renderer()->absoluteBoundingBoxRect();
-        // Move the clip local to the layer position.
-        clip.setLocation(FloatPoint(0, 0));
-#if ENABLE(ANDROID_OVERFLOW_SCROLL)
-        if (layer->hasOverflowScroll()) {
-            // If this is a scrollable layer, inset the clip by the border.
-            RenderBox* box = layer->renderBox();
-            clip.move(box->borderLeft(), box->borderTop());
-            clip.setWidth(clip.width() - box->borderLeft() - box->borderRight());
-            clip.setHeight(clip.height() - box->borderTop() - box->borderBottom());
-        }
-#endif
-        m_contentLayer->setForegroundClip(clip);
-
         return true;
     }
     return false;
@@ -511,7 +526,7 @@ bool GraphicsLayerAndroid::paintContext(SkPicture* context,
 void GraphicsLayerAndroid::setNeedsDisplayInRect(const FloatRect& rect)
 {
     for (unsigned int i = 0; i < m_children.size(); i++) {
-        GraphicsLayerAndroid* layer = static_cast<GraphicsLayerAndroid*>(m_children[i]);
+        GraphicsLayer* layer = m_children[i];
         if (layer) {
             FloatRect childrenRect(m_position.x() + m_translateX + rect.x(),
                                    m_position.y() + m_translateY + rect.y(),
@@ -548,16 +563,6 @@ void GraphicsLayerAndroid::setNeedsDisplayInRect(const FloatRect& rect)
 
     m_needsRepaint = true;
     askForSync();
-
-    if (!m_client)
-        return;
-
-    // Update the layers on the UI
-    RenderLayer* renderLayer = renderLayerFromClient(m_client);
-    if (renderLayer) {
-        FrameView* frameView = renderLayer->root()->renderer()->view()->frameView();
-        PlatformBridge::updateLayers(frameView);
-    }
 }
 
 void GraphicsLayerAndroid::pauseDisplay(bool state)
@@ -862,7 +867,7 @@ void GraphicsLayerAndroid::setContentsToImage(Image* image)
 PlatformLayer* GraphicsLayerAndroid::platformLayer() const
 {
     LOG("platformLayer");
-    return (PlatformLayer*) m_contentLayer;
+    return m_contentLayer;
 }
 
 #ifndef NDEBUG
@@ -884,6 +889,9 @@ void GraphicsLayerAndroid::setZPosition(float position)
 
 void GraphicsLayerAndroid::askForSync()
 {
+    if (!m_client)
+        return;
+
     if (m_client)
         m_client->notifySyncRequired(this);
 }
@@ -892,10 +900,10 @@ void GraphicsLayerAndroid::syncChildren()
 {
     if (m_needsSyncChildren) {
         m_contentLayer->removeChildren();
-        for (unsigned int i = 0; i < m_children.size(); i++) {
-            m_contentLayer->addChild(
-                (static_cast<GraphicsLayerAndroid*>(m_children[i]))->contentLayer());
-        }
+        if (m_foregroundClipLayer)
+            m_contentLayer->addChild(m_foregroundClipLayer);
+        for (unsigned int i = 0; i < m_children.size(); i++)
+            m_contentLayer->addChild(m_children[i]->platformLayer());
         m_needsSyncChildren = false;
     }
 }
@@ -904,8 +912,7 @@ void GraphicsLayerAndroid::syncMask()
 {
     if (m_needsSyncMask) {
         if (m_maskLayer) {
-            GraphicsLayerAndroid* layer = static_cast<GraphicsLayerAndroid*>(m_maskLayer);
-            LayerAndroid* mask = reinterpret_cast<LayerAndroid*>(layer->platformLayer());
+            LayerAndroid* mask = m_maskLayer->platformLayer();
             m_contentLayer->setMaskLayer(mask);
         } else
             m_contentLayer->setMaskLayer(0);
@@ -929,10 +936,8 @@ void GraphicsLayerAndroid::syncPositionState()
 
 void GraphicsLayerAndroid::syncCompositingState()
 {
-    for (unsigned int i = 0; i < m_children.size(); i++) {
-        GraphicsLayerAndroid* layer = static_cast<GraphicsLayerAndroid*>(m_children[i]);
-        layer->syncCompositingState();
-    }
+    for (unsigned int i = 0; i < m_children.size(); i++)
+        m_children[i]->syncCompositingState();
 
     syncChildren();
     syncMask();
@@ -944,10 +949,8 @@ void GraphicsLayerAndroid::syncCompositingState()
 
 void GraphicsLayerAndroid::notifyClientAnimationStarted()
 {
-    for (unsigned int i = 0; i < m_children.size(); i++) {
-        GraphicsLayerAndroid* layer = static_cast<GraphicsLayerAndroid*>(m_children[i]);
-        layer->notifyClientAnimationStarted();
-    }
+    for (unsigned int i = 0; i < m_children.size(); i++)
+        static_cast<GraphicsLayerAndroid*>(m_children[i])->notifyClientAnimationStarted();
 
     if (m_needsNotifyClient) {
         if (client())
diff --git a/WebCore/platform/graphics/android/GraphicsLayerAndroid.h b/WebCore/platform/graphics/android/GraphicsLayerAndroid.h
index 80c92f3..098ad37 100644
--- a/WebCore/platform/graphics/android/GraphicsLayerAndroid.h
+++ b/WebCore/platform/graphics/android/GraphicsLayerAndroid.h
@@ -119,7 +119,6 @@ private:
 
     void askForSync();
     void syncPositionState();
-    void needsSyncChildren();
     void syncChildren();
     void syncMask();
 
@@ -150,6 +149,8 @@ private:
     Vector<FloatRect> m_invalidatedRects;
 
     LayerAndroid* m_contentLayer;
+    LayerAndroid* m_foregroundLayer;
+    LayerAndroid* m_foregroundClipLayer;
 };
 
 } // namespace WebCore
diff --git a/WebCore/platform/graphics/android/LayerAndroid.cpp b/WebCore/platform/graphics/android/LayerAndroid.cpp
index 0a6d3e2..68bdec0 100644
--- a/WebCore/platform/graphics/android/LayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/LayerAndroid.cpp
@@ -13,7 +13,6 @@
 #include "SkPicture.h"
 #include <wtf/CurrentTime.h>
 
-
 #define LAYER_DEBUG // Add diagonals for debugging
 #undef LAYER_DEBUG
 
@@ -52,8 +51,8 @@ LayerAndroid::LayerAndroid(bool isRootLayer) : SkLayer(),
     m_haveClip(false),
     m_doRotation(false),
     m_isFixed(false),
+    m_contentScrollable(false),
     m_recordingPicture(0),
-    m_foregroundPicture(0),
     m_contentsImage(0),
     m_extra(0),
     m_uniqueId(++gUniqueId)
@@ -62,8 +61,6 @@ LayerAndroid::LayerAndroid(bool isRootLayer) : SkLayer(),
     m_translation.set(0, 0);
     m_scale.set(1, 1);
     m_backgroundColor = 0;
-    m_foregroundClip.setEmpty();
-    m_foregroundLocation.set(0, 0);
 
     gDebugLayerAndroidInstances++;
 }
@@ -71,6 +68,7 @@ LayerAndroid::LayerAndroid(bool isRootLayer) : SkLayer(),
 LayerAndroid::LayerAndroid(const LayerAndroid& layer) : SkLayer(layer),
     m_isRootLayer(layer.m_isRootLayer),
     m_haveClip(layer.m_haveClip),
+    m_contentScrollable(layer.m_contentScrollable),
     m_extra(0), // deliberately not copied
     m_uniqueId(layer.m_uniqueId)
 {
@@ -95,12 +93,7 @@ LayerAndroid::LayerAndroid(const LayerAndroid& layer) : SkLayer(layer),
     m_fixedRect = layer.m_fixedRect;
 
     m_recordingPicture = layer.m_recordingPicture;
-    m_foregroundPicture = layer.m_foregroundPicture;
     SkSafeRef(m_recordingPicture);
-    SkSafeRef(m_foregroundPicture);
-
-    m_foregroundClip = layer.m_foregroundClip;
-    m_foregroundLocation = layer.m_foregroundLocation;
 
     for (int i = 0; i < layer.countChildren(); i++)
         addChild(new LayerAndroid(*layer.getChild(i)))->unref();
@@ -117,8 +110,8 @@ LayerAndroid::LayerAndroid(SkPicture* picture) : SkLayer(),
     m_haveClip(false),
     m_doRotation(false),
     m_isFixed(false),
+    m_contentScrollable(false),
     m_recordingPicture(picture),
-    m_foregroundPicture(0),
     m_contentsImage(0),
     m_extra(0),
     m_uniqueId(-1)
@@ -127,8 +120,6 @@ LayerAndroid::LayerAndroid(SkPicture* picture) : SkLayer(),
     m_translation.set(0, 0);
     m_scale.set(1, 1);
     m_backgroundColor = 0;
-    m_foregroundClip.setEmpty();
-    m_foregroundLocation.set(0, 0);
     SkSafeRef(m_recordingPicture);
     gDebugLayerAndroidInstances++;
 }
@@ -138,7 +129,6 @@ LayerAndroid::~LayerAndroid()
     removeChildren();
     m_contentsImage->safeUnref();
     m_recordingPicture->safeUnref();
-    m_foregroundPicture->safeUnref();
     m_animations.clear();
     gDebugLayerAndroidInstances--;
 }
@@ -198,11 +188,6 @@ void LayerAndroid::setMaskLayer(LayerAndroid* layer)
         m_haveClip = true;
 }
 
-void LayerAndroid::setMasksToBounds(bool masksToBounds)
-{
-    m_haveClip = masksToBounds;
-}
-
 void LayerAndroid::setBackgroundColor(SkColor color)
 {
     m_backgroundColor = color;
@@ -323,6 +308,11 @@ public:
     int x() const { return m_x; }
     int y() const { return m_y; }
 
+    void setLocation(int x, int y) {
+        m_x = x;
+        m_y = y;
+    }
+
 protected:
     int m_x;
     int m_y;
@@ -336,18 +326,20 @@ void LayerAndroid::findInner(LayerAndroid::FindState& state) const
 {
     int x = state.x();
     int y = state.y();
-    for (int i = 0; i < countChildren(); i++)
-        getChild(i)->findInner(state);
     SkRect localBounds;
     bounds(&localBounds);
     if (!localBounds.contains(x, y))
         return;
-    if (!m_foregroundPicture) {
-        if (!m_recordingPicture)
-            return;
-        if (!state.drew(m_recordingPicture, localBounds))
-            return;
-    }
+    // Move into local coordinates.
+    state.setLocation(x - localBounds.fLeft, y - localBounds.fTop);
+    for (int i = 0; i < countChildren(); i++)
+        getChild(i)->findInner(state);
+    // Move back into the parent coordinates.
+    state.setLocation(x + localBounds.fLeft, y + localBounds.fTop);
+    if (!m_recordingPicture)
+        return;
+    if (!state.drew(m_recordingPicture, localBounds))
+        return;
     state.setBest(this); // set last match (presumably on top)
 }
 
@@ -450,14 +442,6 @@ void LayerAndroid::onDraw(SkCanvas* canvas, SkScalar opacity) {
       canvas->drawBitmapRect(m_contentsImage->bitmap(), 0, dest);
     } else {
       canvas->drawPicture(*m_recordingPicture);
-      if (m_foregroundPicture) {
-          canvas->save();
-          canvas->clipRect(m_foregroundClip);
-          canvas->translate(-m_foregroundLocation.fX,
-                            -m_foregroundLocation.fY);
-          canvas->drawPicture(*m_foregroundPicture);
-          canvas->restore();
-      }
     }
     if (m_extra) {
         IntRect dummy; // inval area, unused for now
@@ -492,38 +476,48 @@ SkPicture* LayerAndroid::recordContext()
     return 0;
 }
 
-SkPicture* LayerAndroid::foregroundContext()
-{
-    // Always create a new picture since this method is called only when
-    // recording the foreground picture.
-    m_foregroundPicture = new SkPicture();
-    return m_foregroundPicture;
-}
-
-bool LayerAndroid::contentIsScrollable() const {
-    return m_foregroundPicture != 0 &&
-            (getWidth() < SkIntToScalar(m_foregroundPicture->width()) ||
-             getHeight() < SkIntToScalar(m_foregroundPicture->height()));
-}
-
 bool LayerAndroid::scrollBy(int dx, int dy) {
-    if (m_foregroundPicture == 0)
+    if (!contentIsScrollable())
         return false;
-    SkScalar maxScrollX = SkIntToScalar(m_foregroundPicture->width()) - getWidth();
-    SkScalar maxScrollY = SkIntToScalar(m_foregroundPicture->height()) - getHeight();
-    SkScalar x = m_foregroundLocation.fX + dx;
-    SkScalar y = m_foregroundLocation.fY + dy;
-    x = SkScalarClampMax(x, maxScrollX);
-    y = SkScalarClampMax(y, maxScrollY);
-    if (x != m_foregroundLocation.fX || y != m_foregroundLocation.fY) {
-        m_foregroundLocation.set(x, y);
-        return true;
-    }
-    return false;
+
+    // Scrollable layers have a mask layer and then the actual main layer.
+    if (getParent() == 0 || getParent()->getParent() == 0)
+        return false;
+    LayerAndroid* realLayer = static_cast<LayerAndroid*>(getParent()->getParent());
+
+    SkRect scrollBounds;
+    realLayer->bounds(&scrollBounds);
+
+    const SkPoint& maskLayerPosition = getParent()->getPosition();
+    // Our original position is the offset of the mask layer's position.
+    SkScalar maxX = -maskLayerPosition.fX;
+    SkScalar maxY = -maskLayerPosition.fY;
+    SkScalar minX = maxX - (getSize().width() - scrollBounds.width());
+    SkScalar minY = maxY - (getSize().height() - scrollBounds.height());
+
+    // Move the layer's position by the difference and pin the result to within
+    // the scrollable range.
+    SkPoint diff;
+    diff.iset(dx, dy);
+    SkPoint pos = getPosition() - diff;
+    pos.fX = SkScalarPin(pos.fX, minX, maxX);
+    pos.fY = SkScalarPin(pos.fY, minY, maxY);
+
+    // Update the difference to reflect the changes.
+    diff = getPosition() - pos;
+    if (diff.equals(0, 0))
+        // no change
+        return false;
+
+    setPosition(pos.fX, pos.fY);
+    return true;
 }
 
 bool LayerAndroid::prepareContext(bool force)
 {
+    if (masksToBounds())
+        return false;
+
     if (!m_isRootLayer) {
         if (force || !m_recordingPicture
             || (m_recordingPicture
@@ -696,17 +690,6 @@ void LayerAndroid::dumpLayers(FILE* file, int indentLevel) const
         writeIntVal(file, indentLevel + 1, "m_recordingPicture.height", m_recordingPicture->height());
     }
 
-    if (m_foregroundPicture) {
-        writeIntVal(file, indentLevel + 1, "m_foregroundPicture.width", m_foregroundPicture->width());
-        writeIntVal(file, indentLevel + 1, "m_foregroundPicture.height", m_foregroundPicture->height());
-        writeFloatVal(file, indentLevel + 1, "m_foregroundClip.fLeft", m_foregroundClip.fLeft);
-        writeFloatVal(file, indentLevel + 1, "m_foregroundClip.fTop", m_foregroundClip.fTop);
-        writeFloatVal(file, indentLevel + 1, "m_foregroundClip.fRight", m_foregroundClip.fRight);
-        writeFloatVal(file, indentLevel + 1, "m_foregroundClip.fBottom", m_foregroundClip.fBottom);
-        writeFloatVal(file, indentLevel + 1, "m_foregroundLocation.fX", m_foregroundLocation.fX);
-        writeFloatVal(file, indentLevel + 1, "m_foregroundLocation.fY", m_foregroundLocation.fY);
-    }
-
     if (countChildren()) {
         writeln(file, indentLevel + 1, "children = [");
         for (int i = 0; i < countChildren(); i++) {
@@ -732,12 +715,12 @@ void LayerAndroid::dumpToLog() const
     fclose(file);
 }
 
-const LayerAndroid* LayerAndroid::findById(int match) const
+LayerAndroid* LayerAndroid::findById(int match)
 {
     if (m_uniqueId == match)
         return this;
     for (int i = 0; i < countChildren(); i++) {
-        const LayerAndroid* result = getChild(i)->findById(match);
+        LayerAndroid* result = getChild(i)->findById(match);
         if (result)
             return result;
     }
diff --git a/WebCore/platform/graphics/android/LayerAndroid.h b/WebCore/platform/graphics/android/LayerAndroid.h
index 939c95c..a9a9c69 100644
--- a/WebCore/platform/graphics/android/LayerAndroid.h
+++ b/WebCore/platform/graphics/android/LayerAndroid.h
@@ -121,31 +121,18 @@ public:
 
     void setBackgroundColor(SkColor color);
     void setMaskLayer(LayerAndroid*);
-    void setMasksToBounds(bool);
+    void setMasksToBounds(bool masksToBounds) {
+        m_haveClip = masksToBounds;
+    }
+    bool masksToBounds() const { return m_haveClip; }
 
     void setIsRootLayer(bool isRootLayer) { m_isRootLayer = isRootLayer; }
     bool isRootLayer() const { return m_isRootLayer; }
 
     SkPicture* recordContext();
 
-    // The foreground context is used to draw overflow scroll content.
-    SkPicture* foregroundContext();
-
-    // The foreground clip is set when there is content within the node that
-    // can be scrolled (i.e. a div with overflow:scroll).
-    void setForegroundClip(const SkRect& clip) {
-        m_foregroundClip = clip;
-    }
-
-    // Return the foreground clip offset by the position of the layer.
-    SkRect foregroundClip() const { return m_foregroundClip; }
-
-    bool contentIsScrollable() const;
-
     // Returns true if the content position has changed.
     bool scrollBy(int dx, int dy);
-    const SkPoint& scrollPosition() const { return m_foregroundLocation; }
-    void setScrollPosition(const SkPoint& pos) { m_foregroundLocation = pos; }
 
     void addAnimation(PassRefPtr<AndroidAnimation> anim);
     void removeAnimation(const String& name);
@@ -180,7 +167,10 @@ public:
 
     void clipArea(SkTDArray<SkRect>* region) const;
     const LayerAndroid* find(int x, int y, SkPicture* root) const;
-    const LayerAndroid* findById(int uniqueID) const;
+    const LayerAndroid* findById(int uniqueID) const {
+        return const_cast<LayerAndroid*>(this)->findById(uniqueID);
+    }
+    LayerAndroid* findById(int uniqueID);
     LayerAndroid* getChild(int index) const {
         return static_cast<LayerAndroid*>(this->INHERITED::getChild(index));
     }
@@ -196,6 +186,14 @@ public:
     void setContentsImage(SkBitmapRef* img);
 
     void bounds(SkRect* ) const;
+
+    bool contentIsScrollable() const { return m_contentScrollable; }
+
+    // Set when building the layer hierarchy for scrollable elements.
+    void setContentScrollable(bool scrollable) {
+        m_contentScrollable = scrollable;
+    }
+
 protected:
     virtual void onDraw(SkCanvas*, SkScalar opacity);
 
@@ -215,6 +213,7 @@ private:
     bool m_doRotation;
     bool m_isFixed;
     bool m_backgroundColorSet;
+    bool m_contentScrollable;
 
     SkLength m_fixedLeft;
     SkLength m_fixedTop;
@@ -239,15 +238,6 @@ private:
     // it is a much faster method than using m_recordingPicture.
     SkPicture* m_recordingPicture;
 
-    // m_foregroundPicture is set only when compositing a scrollable div.  It
-    // contains the contents minus the background and border which is drawn
-    // first by the rendering tree.  When we draw the layer, we draw
-    // m_recordingPicture (containing the background + border) first and then
-    // clip to m_foregroundClip and draw m_foregroundPicture.
-    SkPicture* m_foregroundPicture;
-    SkRect m_foregroundClip;
-    SkPoint m_foregroundLocation;
-
     SkBitmapRef* m_contentsImage;
 
     typedef HashMap<String, RefPtr<AndroidAnimation> > KeyframesMap;