[BlackBerry] Tie up the scrolling machinery to the graphics tree when applicable...
authortonikitoo@webkit.org <tonikitoo@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 8 Aug 2012 19:21:52 +0000 (19:21 +0000)
committertonikitoo@webkit.org <tonikitoo@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 8 Aug 2012 19:21:52 +0000 (19:21 +0000)
https://bugs.webkit.org/show_bug.cgi?id=93482
PR #187672
Make InRegionScroller a simple public webkit/ API
PR #188677

Reviewed by Rob Buis.
Patch by Antonio Gomes <agomes@rim.com>

In order to prepare InRegionScroller to be a public API
in webkit/, the patch:

1) Renamed the current InRegionScroller class to InRegionScrollerPrivate;
2) Moved InRegionScroller.cpp|h from WebKitSupport/ to Api/;
3) Renamed InRegionScroller.h to InRegionScroller_p.h;
4) Added a new public class implementation to InRegionScroller.h;
5) Adapted WebPage and TouchEventHandler classes to use InRegionScroller::d directly.

The most important API here is '::compositedSetScrollPosition'

It is a  UI/Compositing thread method only and sets the associated LayerCompositingThread
(camouflaged as a unsigned) for each created InRegionScrollableArea that supports
composited scrolling.

The way ::compositedSetScrollPosition "scrolls" a layer is by setting the boundsOrigin
property to the LayerCompositingThread's 'override' property in the UI/Compositing thread.

* PlatformBlackBerry.cmake: Build system adaptation.

* Api/InRegionScroller.cpp: Renamed from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.cpp.
(WebKit):
(BlackBerry::WebKit::InRegionScroller::InRegionScroller):
(BlackBerry::WebKit::InRegionScroller::~InRegionScroller):
(BlackBerry::WebKit::InRegionScroller::compositedSetScrollPosition):
(BlackBerry::WebKit::InRegionScrollerPrivate::InRegionScrollerPrivate):
(BlackBerry::WebKit::InRegionScrollerPrivate::setNode):
(BlackBerry::WebKit::InRegionScrollerPrivate::node):
(BlackBerry::WebKit::InRegionScrollerPrivate::reset):
(BlackBerry::WebKit::InRegionScrollerPrivate::hasNode):
(BlackBerry::WebKit::InRegionScrollerPrivate::canScroll):
(BlackBerry::WebKit::InRegionScrollerPrivate::compositedSetScrollPosition):
(BlackBerry::WebKit::InRegionScrollerPrivate::scrollBy):
(BlackBerry::WebKit::InRegionScrollerPrivate::inRegionScrollableAreasForPoint):
(BlackBerry::WebKit::InRegionScrollerPrivate::scrollNodeRecursively):
(BlackBerry::WebKit::InRegionScrollerPrivate::scrollRenderer):
(BlackBerry::WebKit::InRegionScrollerPrivate::adjustScrollDelta):
(BlackBerry::WebKit::canScrollInnerFrame):
(BlackBerry::WebKit::canScrollRenderBox):
(BlackBerry::WebKit::parentLayer):
(BlackBerry::WebKit::enclosingLayerNode):
(BlackBerry::WebKit::isNonRenderViewFixedPositionedContainer):
(BlackBerry::WebKit::pushBackInRegionScrollable):
* Api/InRegionScroller.h: Copied from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.h.
(WebKit):
(InRegionScroller):
* Api/InRegionScroller_p.h: Renamed from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.h.
(WebCore):
(WebKit):
(InRegionScrollerPrivate):
* Api/WebPage.cpp:
(BlackBerry::WebKit::WebPagePrivate::scrollBy):
(BlackBerry::WebKit::WebPagePrivate::notifyInRegionScrollStatusChanged):
(BlackBerry::WebKit::WebPagePrivate::clearDocumentData):
(BlackBerry::WebKit::WebPagePrivate::setScrollOriginPoint):
(BlackBerry::WebKit::WebPage::inRegionScroller):
(WebKit):
* Api/WebPage.h:
(WebKit):
* WebKitSupport/InRegionScrollableArea.cpp:
(BlackBerry::WebKit::InRegionScrollableArea::InRegionScrollableArea):
* WebKitSupport/TouchEventHandler.cpp:
(BlackBerry::WebKit::TouchEventHandler::drawTapHighlight):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@125071 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebKit/ChangeLog
Source/WebKit/PlatformBlackBerry.cmake
Source/WebKit/blackberry/Api/InRegionScroller.cpp [moved from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.cpp with 82% similarity]
Source/WebKit/blackberry/Api/InRegionScroller.h [new file with mode: 0644]
Source/WebKit/blackberry/Api/InRegionScroller_p.h [moved from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.h with 85% similarity]
Source/WebKit/blackberry/Api/WebPage.cpp
Source/WebKit/blackberry/Api/WebPage.h
Source/WebKit/blackberry/ChangeLog
Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.cpp
Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.cpp

index df8b892..189561f 100644 (file)
@@ -1,3 +1,12 @@
+2012-08-08  Antonio Gomes  <agomes@rim.com>
+
+        [BlackBerry] Tie up the scrolling machinery to the graphics tree when applicable for in-region scroll
+        https://bugs.webkit.org/show_bug.cgi?id=93482
+
+        Reviewed by Rob Buis.
+
+        * PlatformBlackBerry.cmake: Build system adaptation.
+
 2012-08-07  Ryuan Choi  <ryuan.choi@samsung.com>
 
         [EFL] Remove PlatformTouchEventEfl and PlatformTouchPointEfl
index ee11ed6..a781529 100644 (file)
@@ -57,6 +57,7 @@ ADD_DEFINITIONS(-DUSER_PROCESSES)
 LIST(APPEND WebKit_SOURCES
     blackberry/Api/BackingStore.cpp
     blackberry/Api/BlackBerryGlobal.cpp
+    blackberry/Api/InRegionScroller.cpp
     blackberry/Api/WebAnimation.cpp
     blackberry/Api/WebKitMIMETypeConverter.cpp
     blackberry/Api/WebKitTextCodec.cpp
@@ -100,7 +101,6 @@ LIST(APPEND WebKit_SOURCES
     blackberry/WebKitSupport/InPageSearchManager.cpp
     blackberry/WebKitSupport/InputHandler.cpp
     blackberry/WebKitSupport/InRegionScrollableArea.cpp
-    blackberry/WebKitSupport/InRegionScroller.cpp
     blackberry/WebKitSupport/InspectorOverlay.cpp
     blackberry/WebKitSupport/RenderQueue.cpp
     blackberry/WebKitSupport/SelectionHandler.cpp
@@ -24,6 +24,8 @@
 #include "HTMLFrameOwnerElement.h"
 #include "HitTestResult.h"
 #include "InRegionScrollableArea.h"
+#include "InRegionScroller_p.h"
+#include "LayerCompositingThread.h"
 #include "Page.h"
 #include "RenderBox.h"
 #include "RenderLayer.h"
@@ -36,130 +38,80 @@ using namespace WebCore;
 namespace BlackBerry {
 namespace WebKit {
 
-static bool canScrollInnerFrame(Frame* frame)
-{
-    if (!frame || !frame->view())
-        return false;
-
-    // Not having an owner element means that we are on the mainframe.
-    if (!frame->ownerElement())
-        return false;
-
-    ASSERT(frame != frame->page()->mainFrame());
-
-    IntSize visibleSize = frame->view()->visibleContentRect().size();
-    IntSize contentsSize = frame->view()->contentsSize();
-
-    bool canBeScrolled = contentsSize.height() > visibleSize.height() || contentsSize.width() > visibleSize.width();
-
-    // Lets also consider the 'overflow-{x,y} property set directly to the {i}frame tag.
-    return canBeScrolled && (frame->ownerElement()->scrollingMode() != ScrollbarAlwaysOff);
-}
-
-// The RenderBox::canbeScrolledAndHasScrollableArea method returns true for the
-// following scenario, for example:
-// (1) a div that has a vertical overflow but no horizontal overflow
-//     with overflow-y: hidden and overflow-x: auto set.
-// The version below fixes it.
-// FIXME: Fix RenderBox::canBeScrolledAndHasScrollableArea method instead.
-static bool canScrollRenderBox(RenderBox* box)
-{
-    if (!box || !box->hasOverflowClip())
-        return false;
-
-    if (box->scrollsOverflowX() && (box->scrollWidth() != box->clientWidth())
-        || box->scrollsOverflowY() && (box->scrollHeight() != box->clientHeight()))
-        return true;
-
-    Node* node = box->node();
-    return node && (node->rendererIsEditable() || node->isDocumentNode());
-}
-
-static RenderLayer* parentLayer(RenderLayer* layer)
-{
-    ASSERT(layer);
-    if (layer->parent())
-        return layer->parent();
+static bool canScrollInnerFrame(Frame*);
+static bool canScrollRenderBox(RenderBox*);
+static RenderLayer* parentLayer(RenderLayer*);
+static Node* enclosingLayerNode(RenderLayer*);
+static bool isNonRenderViewFixedPositionedContainer(RenderLayer*);
+static void pushBackInRegionScrollable(std::vector<Platform::ScrollViewBase*>&, InRegionScrollableArea*, InRegionScrollerPrivate*);
 
-    RenderObject* renderer = layer->renderer();
-    if (renderer->document() && renderer->document()->ownerElement() && renderer->document()->ownerElement()->renderer())
-        return renderer->document()->ownerElement()->renderer()->enclosingLayer();
-
-    return 0;
-}
-
-// FIXME: Make RenderLayer::enclosingElement public so this one can be removed.
-static Node* enclosingLayerNode(RenderLayer* layer)
+InRegionScroller::InRegionScroller(WebPagePrivate* webPagePrivate)
+    : d(new InRegionScrollerPrivate(webPagePrivate))
 {
-    for (RenderObject* r = layer->renderer(); r; r = r->parent()) {
-        if (Node* e = r->node())
-            return e;
-    }
-    ASSERT_NOT_REACHED();
-    return 0;
+    ASSERT(webPagePrivate);
 }
 
-static bool isNonRenderViewFixedPositionedContainer(RenderLayer* layer)
+InRegionScroller::~InRegionScroller()
 {
-    RenderObject* o = layer->renderer();
-    if (o->isRenderView())
-        return false;
-
-    return o->isPositioned() && o->style()->position() == FixedPosition;
+    delete d;
 }
 
-static void pushBackInRegionScrollable(std::vector<Platform::ScrollViewBase*>& vector, InRegionScrollableArea* scrollableArea, InRegionScroller* scroller)
+bool InRegionScroller::compositedSetScrollPosition(unsigned camouflagedLayer, const Platform::IntPoint& scrollPosition)
 {
-    ASSERT(scroller);
-    ASSERT(!scrollableArea->isNull());
-
-    scrollableArea->setCanPropagateScrollingToEnclosingScrollable(!isNonRenderViewFixedPositionedContainer(scrollableArea->layer()));
-    vector.push_back(scrollableArea);
-    if (vector.size() == 1) {
-        // FIXME: Use RenderLayer::renderBox()->node() instead?
-        scroller->setNode(enclosingLayerNode(scrollableArea->layer()));
-    }
+    ASSERT(Platform::userInterfaceThreadMessageClient()->isCurrentThread());
+    return d->compositedSetScrollPosition(camouflagedLayer, d->m_webPage->mapFromTransformed(scrollPosition));
 }
 
-InRegionScroller::InRegionScroller(WebPagePrivate* webPagePrivate)
+InRegionScrollerPrivate::InRegionScrollerPrivate(WebPagePrivate* webPagePrivate)
     : m_webPage(webPagePrivate)
 {
 }
 
-void InRegionScroller::setNode(WebCore::Node* node)
+void InRegionScrollerPrivate::setNode(WebCore::Node* node)
 {
     m_inRegionScrollStartingNode = node;
 }
 
-WebCore::Node* InRegionScroller::node() const
+WebCore::Node* InRegionScrollerPrivate::node() const
 {
     return m_inRegionScrollStartingNode.get();
 }
 
-void InRegionScroller::reset()
+void InRegionScrollerPrivate::reset()
 {
     setNode(0);
 }
 
-bool InRegionScroller::hasNode() const
+bool InRegionScrollerPrivate::hasNode() const
 {
     return !!m_inRegionScrollStartingNode;
 }
 
-bool InRegionScroller::canScroll() const
+bool InRegionScrollerPrivate::canScroll() const
 {
     return hasNode();
 }
 
-bool InRegionScroller::scrollBy(const Platform::IntSize& delta)
+bool InRegionScrollerPrivate::compositedSetScrollPosition(unsigned camouflagedLayer, const WebCore::IntPoint& scrollPosition)
+{
+    LayerCompositingThread* scrollLayer = reinterpret_cast<LayerCompositingThread*>(camouflagedLayer);
+    scrollLayer->override()->setBoundsOrigin(WebCore::FloatPoint(scrollPosition.x(), scrollPosition.y()));
+
+    m_webPage->scheduleCompositingRun();
+    return true;
+}
+
+bool InRegionScrollerPrivate::scrollBy(const Platform::IntSize& delta)
 {
+    ASSERT(Platform::webkitThreadMessageClient()->isCurrentThread());
+
     if (!canScroll())
         return false;
 
     return scrollNodeRecursively(node(), delta);
 }
 
-std::vector<Platform::ScrollViewBase*> InRegionScroller::inRegionScrollableAreasForPoint(const WebCore::IntPoint& point)
+std::vector<Platform::ScrollViewBase*> InRegionScrollerPrivate::inRegionScrollableAreasForPoint(const WebCore::IntPoint& point)
 {
     std::vector<Platform::ScrollViewBase*> validReturn;
     std::vector<Platform::ScrollViewBase*> emptyReturn;
@@ -240,7 +192,7 @@ std::vector<Platform::ScrollViewBase*> InRegionScroller::inRegionScrollableAreas
     return validReturn;
 }
 
-bool InRegionScroller::scrollNodeRecursively(WebCore::Node* node, const WebCore::IntSize& delta)
+bool InRegionScrollerPrivate::scrollNodeRecursively(WebCore::Node* node, const WebCore::IntSize& delta)
 {
     if (delta.isZero())
         return true;
@@ -304,7 +256,7 @@ bool InRegionScroller::scrollNodeRecursively(WebCore::Node* node, const WebCore:
     return false;
 }
 
-bool InRegionScroller::scrollRenderer(WebCore::RenderObject* renderer, const WebCore::IntSize& delta)
+bool InRegionScrollerPrivate::scrollRenderer(WebCore::RenderObject* renderer, const WebCore::IntSize& delta)
 {
     RenderLayer* layer = renderer->enclosingLayer();
     if (!layer)
@@ -323,7 +275,7 @@ bool InRegionScroller::scrollRenderer(WebCore::RenderObject* renderer, const Web
         if (!layerDelta.isZero()) {
             setNode(enclosingLayerNode(layer));
             IntPoint newOffset = currentOffset + layerDelta;
-            layer->scrollToOffset(newOffset.x(), newOffset.y());
+            layer->scrollToOffset(IntSize(newOffset.x(), newOffset.y()));
             renderer->repaint(true);
             return true;
         }
@@ -337,7 +289,7 @@ bool InRegionScroller::scrollRenderer(WebCore::RenderObject* renderer, const Web
     return false;
 }
 
-void InRegionScroller::adjustScrollDelta(const WebCore::IntPoint& maxOffset, const WebCore::IntPoint& currentOffset, WebCore::IntSize& delta) const
+void InRegionScrollerPrivate::adjustScrollDelta(const WebCore::IntPoint& maxOffset, const WebCore::IntPoint& currentOffset, WebCore::IntSize& delta) const
 {
     if (currentOffset.x() + delta.width() > maxOffset.x())
         delta.setWidth(std::min(maxOffset.x() - currentOffset.x(), delta.width()));
@@ -352,5 +304,90 @@ void InRegionScroller::adjustScrollDelta(const WebCore::IntPoint& maxOffset, con
         delta.setHeight(std::max(-currentOffset.y(), delta.height()));
 }
 
+static bool canScrollInnerFrame(Frame* frame)
+{
+    if (!frame || !frame->view())
+        return false;
+
+    // Not having an owner element means that we are on the mainframe.
+    if (!frame->ownerElement())
+        return false;
+
+    ASSERT(frame != frame->page()->mainFrame());
+
+    IntSize visibleSize = frame->view()->visibleContentRect().size();
+    IntSize contentsSize = frame->view()->contentsSize();
+
+    bool canBeScrolled = contentsSize.height() > visibleSize.height() || contentsSize.width() > visibleSize.width();
+
+    // Lets also consider the 'overflow-{x,y} property set directly to the {i}frame tag.
+    return canBeScrolled && (frame->ownerElement()->scrollingMode() != ScrollbarAlwaysOff);
+}
+
+// The RenderBox::canbeScrolledAndHasScrollableArea method returns true for the
+// following scenario, for example:
+// (1) a div that has a vertical overflow but no horizontal overflow
+//     with overflow-y: hidden and overflow-x: auto set.
+// The version below fixes it.
+// FIXME: Fix RenderBox::canBeScrolledAndHasScrollableArea method instead.
+static bool canScrollRenderBox(RenderBox* box)
+{
+    if (!box || !box->hasOverflowClip())
+        return false;
+
+    if (box->scrollsOverflowX() && (box->scrollWidth() != box->clientWidth())
+        || box->scrollsOverflowY() && (box->scrollHeight() != box->clientHeight()))
+        return true;
+
+    Node* node = box->node();
+    return node && (node->rendererIsEditable() || node->isDocumentNode());
+}
+
+static RenderLayer* parentLayer(RenderLayer* layer)
+{
+    ASSERT(layer);
+    if (layer->parent())
+        return layer->parent();
+
+    RenderObject* renderer = layer->renderer();
+    if (renderer->document() && renderer->document()->ownerElement() && renderer->document()->ownerElement()->renderer())
+        return renderer->document()->ownerElement()->renderer()->enclosingLayer();
+
+    return 0;
+}
+
+// FIXME: Make RenderLayer::enclosingElement public so this one can be removed.
+static Node* enclosingLayerNode(RenderLayer* layer)
+{
+    for (RenderObject* r = layer->renderer(); r; r = r->parent()) {
+        if (Node* e = r->node())
+            return e;
+    }
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
+static bool isNonRenderViewFixedPositionedContainer(RenderLayer* layer)
+{
+    RenderObject* o = layer->renderer();
+    if (o->isRenderView())
+        return false;
+
+    return o->isOutOfFlowPositioned() && o->style()->position() == FixedPosition;
+}
+
+static void pushBackInRegionScrollable(std::vector<Platform::ScrollViewBase*>& vector, InRegionScrollableArea* scrollableArea, InRegionScrollerPrivate* scroller)
+{
+    ASSERT(scroller);
+    ASSERT(!scrollableArea->isNull());
+
+    scrollableArea->setCanPropagateScrollingToEnclosingScrollable(!isNonRenderViewFixedPositionedContainer(scrollableArea->layer()));
+    vector.push_back(scrollableArea);
+    if (vector.size() == 1) {
+        // FIXME: Use RenderLayer::renderBox()->node() instead?
+        scroller->setNode(enclosingLayerNode(scrollableArea->layer()));
+    }
+}
+
 }
 }
diff --git a/Source/WebKit/blackberry/Api/InRegionScroller.h b/Source/WebKit/blackberry/Api/InRegionScroller.h
new file mode 100644 (file)
index 0000000..ed37afc
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef InRegionScroller_h
+#define InRegionScroller_h
+
+#include <BlackBerryPlatformPrimitives.h>
+
+namespace BlackBerry {
+namespace WebKit {
+
+class InRegionScrollerPrivate;
+class TouchEventHandler;
+class WebPagePrivate;
+
+class InRegionScroller {
+public:
+    InRegionScroller(WebPagePrivate*);
+    ~InRegionScroller();
+
+    bool compositedSetScrollPosition(unsigned /*camouflagedLayer*/, const Platform::IntPoint& /*scrollPosition*/);
+
+private:
+    friend class WebPagePrivate;
+    friend class TouchEventHandler;
+    InRegionScrollerPrivate *d;
+};
+
+}
+}
+
+#endif
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#ifndef InRegionScroller_h
-#define InRegionScroller_h
+#ifndef InRegionScroller_p_h
+#define InRegionScroller_p_h
 
-#include "IntRect.h"
+#include "IntSize.h"
+#include "IntPoint.h"
 
 #include <interaction/ScrollViewBase.h>
 #include <vector>
@@ -35,10 +36,9 @@ namespace WebKit {
 
 class WebPagePrivate;
 
-class InRegionScroller {
-
+class InRegionScrollerPrivate {
 public:
-    InRegionScroller(WebPagePrivate*);
+    InRegionScrollerPrivate(WebPagePrivate*);
 
     void setNode(WebCore::Node*);
     WebCore::Node* node() const;
@@ -48,17 +48,18 @@ public:
     bool hasNode() const;
 
     bool scrollBy(const Platform::IntSize& delta);
+    bool compositedSetScrollPosition(unsigned camouflagedLayer, const WebCore::IntPoint& scrollPosition);
 
     std::vector<Platform::ScrollViewBase*> inRegionScrollableAreasForPoint(const WebCore::IntPoint&);
-private:
 
+    WebPagePrivate* m_webPage;
+
+private:
     bool scrollNodeRecursively(WebCore::Node*, const WebCore::IntSize& delta);
     bool scrollRenderer(WebCore::RenderObject*, const WebCore::IntSize& delta);
-
     void adjustScrollDelta(const WebCore::IntPoint& maxOffset, const WebCore::IntPoint& currentOffset, WebCore::IntSize& delta) const;
 
     RefPtr<WebCore::Node> m_inRegionScrollStartingNode;
-    WebPagePrivate* m_webPage;
 };
 
 }
index b5494ad..cdfa81c 100644 (file)
@@ -71,6 +71,7 @@
 #include "IconDatabaseClientBlackBerry.h"
 #include "InPageSearchManager.h"
 #include "InRegionScrollableArea.h"
+#include "InRegionScroller_p.h"
 #include "InputHandler.h"
 #include "InspectorBackendDispatcher.h"
 #include "InspectorClientBlackBerry.h"
@@ -1522,7 +1523,7 @@ bool WebPagePrivate::scrollBy(int deltaX, int deltaY, bool scrollMainFrame)
             delta.width() < 0 ? -untransformedCopiedDelta.width() : untransformedCopiedDelta.width(),
             delta.height() < 0 ? -untransformedCopiedDelta.height(): untransformedCopiedDelta.height());
 
-        if (m_inRegionScroller->scrollBy(delta)) {
+        if (m_inRegionScroller->d->scrollBy(delta)) {
             m_selectionHandler->selectionPositionChanged();
             // FIXME: We have code in place to handle scrolling and clipping tap highlight
             // on in-region scrolling. As soon as it is fast enough (i.e. we have it backed by
@@ -1548,9 +1549,9 @@ bool WebPage::scrollBy(const Platform::IntSize& delta, bool scrollMainFrame)
 
 void WebPagePrivate::notifyInRegionScrollStatusChanged(bool status)
 {
-    if (!status && m_inRegionScroller->hasNode()) {
-        enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling(m_inRegionScroller->node());
-        m_inRegionScroller->reset();
+    if (!status && m_inRegionScroller->d->hasNode()) {
+        enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling(m_inRegionScroller->d->node());
+        m_inRegionScroller->d->reset();
     }
 }
 
@@ -2633,8 +2634,8 @@ void WebPagePrivate::clearDocumentData(const Document* documentGoingAway)
     if (m_currentBlockZoomAdjustedNode && m_currentBlockZoomAdjustedNode->document() == documentGoingAway)
         m_currentBlockZoomAdjustedNode = 0;
 
-    if (m_inRegionScroller->hasNode() && m_inRegionScroller->node()->document() == documentGoingAway)
-        m_inRegionScroller->reset();
+    if (m_inRegionScroller->d->hasNode() && m_inRegionScroller->d->node()->document() == documentGoingAway)
+        m_inRegionScroller->d->reset();
 
     if (documentGoingAway->frame())
         m_inputHandler->frameUnloaded(documentGoingAway->frame());
@@ -4211,12 +4212,12 @@ bool WebPage::touchEvent(const Platform::TouchEvent& event)
 
 void WebPagePrivate::setScrollOriginPoint(const Platform::IntPoint& point)
 {
-    m_inRegionScroller->reset();
+    m_inRegionScroller->d->reset();
 
     if (!m_hasInRegionScrollableAreas)
         return;
 
-    m_client->notifyInRegionScrollingStartingPointChanged(m_inRegionScroller->inRegionScrollableAreasForPoint(point));
+    m_client->notifyInRegionScrollingStartingPointChanged(m_inRegionScroller->d->inRegionScrollableAreasForPoint(point));
 }
 
 void WebPage::setScrollOriginPoint(const Platform::IntPoint& point)
@@ -4654,6 +4655,11 @@ BackingStore* WebPage::backingStore() const
     return d->m_backingStore;
 }
 
+InRegionScroller* WebPage::inRegionScroller() const
+{
+    return d->m_inRegionScroller.get();
+}
+
 bool WebPage::zoomToFit()
 {
     if (d->contentsSize().isEmpty() || !d->isUserScalable())
index 1f0a751..2405a75 100644 (file)
@@ -63,6 +63,7 @@ namespace WebKit {
 class BackingStore;
 class BackingStoreClient;
 class BackingStorePrivate;
+class InRegionScroller;
 class RenderQueue;
 class WebOverlay;
 class WebPageClient;
@@ -179,6 +180,8 @@ public:
 
     BackingStore* backingStore() const;
 
+    InRegionScroller* inRegionScroller() const;
+
     bool zoomToFit();
     bool zoomToOneOne();
     void zoomToInitialScale();
index 007052a..433354c 100644 (file)
@@ -1,5 +1,77 @@
 2012-08-08  Antonio Gomes  <agomes@rim.com>
 
+        [BlackBerry] Tie up the scrolling machinery to the graphics tree when applicable for in-region scroll
+        https://bugs.webkit.org/show_bug.cgi?id=93482
+        PR #187672
+        Make InRegionScroller a simple public webkit/ API
+        PR #188677
+
+        Reviewed by Rob Buis.
+
+        In order to prepare InRegionScroller to be a public API
+        in webkit/, the patch:
+
+        1) Renamed the current InRegionScroller class to InRegionScrollerPrivate;
+        2) Moved InRegionScroller.cpp|h from WebKitSupport/ to Api/;
+        3) Renamed InRegionScroller.h to InRegionScroller_p.h;
+        4) Added a new public class implementation to InRegionScroller.h;
+        5) Adapted WebPage and TouchEventHandler classes to use InRegionScroller::d directly.
+
+        The most important API here is '::compositedSetScrollPosition'
+
+        It is a  UI/Compositing thread method only and sets the associated LayerCompositingThread
+        (camouflaged as a unsigned) for each created InRegionScrollableArea that supports
+        composited scrolling.
+
+        The way ::compositedSetScrollPosition "scrolls" a layer is by setting the boundsOrigin
+        property to the LayerCompositingThread's 'override' property in the UI/Compositing thread.
+
+        * Api/InRegionScroller.cpp: Renamed from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.cpp.
+        (WebKit):
+        (BlackBerry::WebKit::InRegionScroller::InRegionScroller):
+        (BlackBerry::WebKit::InRegionScroller::~InRegionScroller):
+        (BlackBerry::WebKit::InRegionScroller::compositedSetScrollPosition):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::InRegionScrollerPrivate):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::setNode):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::node):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::reset):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::hasNode):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::canScroll):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::compositedSetScrollPosition):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::scrollBy):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::inRegionScrollableAreasForPoint):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::scrollNodeRecursively):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::scrollRenderer):
+        (BlackBerry::WebKit::InRegionScrollerPrivate::adjustScrollDelta):
+        (BlackBerry::WebKit::canScrollInnerFrame):
+        (BlackBerry::WebKit::canScrollRenderBox):
+        (BlackBerry::WebKit::parentLayer):
+        (BlackBerry::WebKit::enclosingLayerNode):
+        (BlackBerry::WebKit::isNonRenderViewFixedPositionedContainer):
+        (BlackBerry::WebKit::pushBackInRegionScrollable):
+        * Api/InRegionScroller.h: Copied from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.h.
+        (WebKit):
+        (InRegionScroller):
+        * Api/InRegionScroller_p.h: Renamed from Source/WebKit/blackberry/WebKitSupport/InRegionScroller.h.
+        (WebCore):
+        (WebKit):
+        (InRegionScrollerPrivate):
+        * Api/WebPage.cpp:
+        (BlackBerry::WebKit::WebPagePrivate::scrollBy):
+        (BlackBerry::WebKit::WebPagePrivate::notifyInRegionScrollStatusChanged):
+        (BlackBerry::WebKit::WebPagePrivate::clearDocumentData):
+        (BlackBerry::WebKit::WebPagePrivate::setScrollOriginPoint):
+        (BlackBerry::WebKit::WebPage::inRegionScroller):
+        (WebKit):
+        * Api/WebPage.h:
+        (WebKit):
+        * WebKitSupport/InRegionScrollableArea.cpp:
+        (BlackBerry::WebKit::InRegionScrollableArea::InRegionScrollableArea):
+        * WebKitSupport/TouchEventHandler.cpp:
+        (BlackBerry::WebKit::TouchEventHandler::drawTapHighlight):
+
+2012-08-08  Antonio Gomes  <agomes@rim.com>
+
         [BlackBerry] Make WebOverlayPrivate::scheduleCompositingRun a WebPagePrivate method.
         https://bugs.webkit.org/show_bug.cgi?id=93480
         PR #188682
index 76a980e..d42059e 100644 (file)
 #include "InRegionScrollableArea.h"
 
 #include "Frame.h"
+#include "LayerCompositingThread.h"
+#include "LayerWebKitThread.h"
 #include "RenderBox.h"
 #include "RenderLayer.h"
+#include "RenderLayerBacking.h"
 #include "RenderObject.h"
 #include "RenderView.h"
 #include "WebPage_p.h"
@@ -68,6 +71,8 @@ InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLa
         m_scrollsVertically = view->contentsHeight() > view->visibleHeight();
 
         m_overscrollLimitFactor = 0.0; // FIXME eventually support overscroll
+        m_cachedCompositedScrollableLayer = 0; // FIXME: Needs composited layer for inner frames.
+
     } else { // RenderBox-based elements case (scrollable boxes (div's, p's, textarea's, etc)).
 
         RenderBox* box = m_layer->renderBox();
@@ -82,7 +87,13 @@ InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLa
         m_scrollsHorizontally = box->scrollWidth() != box->clientWidth() && box->scrollsOverflowX();
         m_scrollsVertically = box->scrollHeight() != box->clientHeight() && box->scrollsOverflowY();
 
-        m_overscrollLimitFactor = 0.0; // FIXME eventually support overscroll
+        if (m_layer->usesCompositedScrolling()) {
+            m_supportsCompositedScrolling = true;
+            ASSERT(m_layer->backing()->hasScrollingLayer());
+            m_cachedCompositedScrollableLayer = reinterpret_cast<unsigned>(m_layer->backing()->scrollingLayer()->platformLayer()->layerCompositingThread());
+        }
+
+        m_overscrollLimitFactor = 0.0;
     }
 }
 
index b4113ba..492aeaa 100644 (file)
@@ -31,6 +31,7 @@
 #include "HTMLInputElement.h"
 #include "HTMLNames.h"
 #include "HTMLPlugInElement.h"
+#include "InRegionScroller_p.h"
 #include "InputHandler.h"
 #include "IntRect.h"
 #include "IntSize.h"
@@ -363,7 +364,7 @@ void TouchEventHandler::drawTapHighlight()
     // On the client side, this info is being used to hide the tap highlight window on scroll.
     RenderLayer* layer = m_webPage->enclosingFixedPositionedAncestorOrSelfIfFixedPositioned(renderer->enclosingLayer());
     bool shouldHideTapHighlightRightAfterScrolling = !layer->renderer()->isRenderView();
-    shouldHideTapHighlightRightAfterScrolling |= !!m_webPage->m_inRegionScroller->node();
+    shouldHideTapHighlightRightAfterScrolling |= !!m_webPage->m_inRegionScroller->d->node();
 
     IntPoint framePos(m_webPage->frameOffset(elementFrame));