Implement top controls show/hide functionality for main thread scrolling

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 395 matching lines @@
     , m_fullscreenController(FullscreenController::create(this))
     , m_showFPSCounter(false)
     , m_showPaintRects(false)
     , m_showDebugBorders(false)
     , m_continuousPaintingEnabled(false)
     , m_showScrollBottleneckRects(false)
     , m_baseBackgroundColor(Color::white)
     , m_backgroundColorOverride(Color::transparent)
     , m_zoomFactorOverride(0)
     , m_userGestureObserved(false)
-    , m_topControlsShownRatio(0)
-    , m_topControlsHeight(0)
-    , m_topControlsShrinkLayoutSize(true)
+    , m_topControls(adoptPtr(new TopControls(this)))
 {
     Page::PageClients pageClients;
     pageClients.chromeClient = &m_chromeClientImpl;
     pageClients.contextMenuClient = &m_contextMenuClientImpl;
     pageClients.editorClient = &m_editorClientImpl;
     pageClients.dragClient = &m_dragClientImpl;
     pageClients.inspectorClient = &m_inspectorClientImpl;
     pageClients.spellCheckerClient = &m_spellCheckerClientImpl;
 
     m_page = adoptPtrWillBeNoop(new Page(pageClients));
@@ skipping 261 matching lines @@
         }
         // GestureDoubleTap is currently only used by Android for zooming. For WebCore,
         // GestureTap with tap count = 2 is used instead. So we drop GestureDoubleTap here.
         eventSwallowed = true;
         m_client->didHandleGestureEvent(event, eventCancelled);
         return eventSwallowed;
     case WebInputEvent::GestureScrollBegin:
         m_client->cancelScheduledContentIntents();
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureScrollUpdate:
-    case WebInputEvent::GestureFlingStart:
+    case WebInputEvent::GestureFlingStart: {
+        // Top Controls scrolling happens before anything else. If top controls
+        // consumed any delta consider event consumed.
+        // FIXME: Add a flag in settings that controls top control feature.

[aelias_OOO_until_Jul13, 2015/02/13 02:03:17]

I don't think we should ever add a setting.  Top-controls are no-op if the
height is 0, and I don't think the tiny additional CPU time is a problem.  Let's
remove the TODO.

[majidvp, 2015/02/18 21:03:57]

Done.

+        float remainigDeltaY = 0.f;

[aelias_OOO_until_Jul13, 2015/02/13 02:03:17]

Typo: "remaining"

[majidvp, 2015/02/18 21:03:57]

Done.

+        eventSwallowed = m_topControls->handleGestureEvent(platformEvent, &remainigDeltaY);
+
+        if (eventSwallowed) {
+            // Modify event to adjust vertical scroll delta before passing to |EventHandler|.

[aelias_OOO_until_Jul13, 2015/02/13 02:03:17]

Top controls don't have priority over scrollable subregions.  The delta needs to
be taken away before the main frame scroll but not earlier.  This means the call
into TopControls likely needs to be moved elsewhere.  Given this, it may also be
no longer natural for top controls to "handleGestureEvent" as I don't think
that's how scroll deltas are bubbled elsewhere; TopControls could just take a
delta directly.

After fixing this, please add a unit test that top controls don't absorb scrolls
on scrollable subregions.

[bokan, 2015/02/13 12:35:25]

Right, I think this should go in EventHandler::handleGestureScrollUpdate and
EventHandler::handleWheelEvent, after scrolling any subframes/scrollable areas
but before scrolling the main frame or pinch viewport. This also means that
TopControls should live inside Blink core; like PinchViewport, hanging it inside
FrameHost probably makes the most sense. 

[majidvp, 2015/02/18 21:03:57]

I moved TopControls inside FrameHost and remove its handleGestureEvent method.
Instead appropriate methods are individually invoked by EventHandler.

+            // The event is passed to |EventHandler| even if deltaY is fully consumed by top
+            // controls to ensure that document consumes any horizontal scroll delta.
+            platformEvent = PlatformGestureEventBuilder(mainFrameImpl()->frameView(), event,
+                platformEvent.deltaX(), remainigDeltaY);
+        }
+
         // Scrolling-related gesture events invoke EventHandler recursively for each frame down
         // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
         // Perhaps we could simplify things by rewriting scroll handling to work inner frame
         // out, and then unify with other gesture events.
-        eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(platformEvent);
+        eventSwallowed |= mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(platformEvent);
         m_client->didHandleGestureEvent(event, eventCancelled);
         return eventSwallowed;
+    }
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::GesturePinchUpdate:
-        // Gesture pinch events are aborted in PageWidgetDelegate::handleInputEvent and should
-        // not reach here.
-        ASSERT_NOT_REACHED();
+        m_topControls->handleGestureEvent(platformEvent, 0);
         return false;
     default:
         break;
     }
 
     // Hit test across all frames and do touch adjustment as necessary for the event type.
     GestureEventWithHitTestResults targetedEvent =
         m_page->deprecatedLocalMainFrame()->eventHandler().targetGestureEvent(platformEvent);
 
     // Handle link highlighting outside the main switch to avoid getting lost in the
@@ skipping 977 matching lines @@
     if (page()->inspectorController().deviceEmulationEnabled()) {
         if (Document* document = mainFrameImpl()->frame()->document()) {
             document->styleResolverChanged();
             document->mediaQueryAffectingValueChanged();
         }
     }
 }
 
 void WebViewImpl::setTopControlsShownRatio(float offset)
 {
-    m_topControlsShownRatio = offset;
-    m_layerTreeView->setTopControlsShownRatio(offset);
-    didUpdateTopControls();
+    m_topControls->setShownRatio(offset);
 }
 
 void WebViewImpl::setTopControlsHeight(float height, bool topControlsShrinkLayoutSize)
 {
-    if (m_topControlsHeight == height && m_topControlsShrinkLayoutSize == topControlsShrinkLayoutSize)
-        return;
+    m_topControls->setHeight(height);
+    m_topControls->setShrinkViewport(topControlsShrinkLayoutSize);
 
-    m_topControlsHeight = height;
-    m_topControlsShrinkLayoutSize = topControlsShrinkLayoutSize;
-    didUpdateTopControls();
+    m_layerTreeView->setTopControlsHeight(height);

[aelias_OOO_until_Jul13, 2015/02/13 02:03:17]

Would be more consistent to put this in didUpdateTopControls.

[majidvp, 2015/02/18 21:03:57]

Done.

+    m_layerTreeView->setTopControlsShrinkBlinkSize(topControlsShrinkLayoutSize);
+
+}
+
+void WebViewImpl::updateTopControlsState(WebTopControlsState constraint, WebTopControlsState current, bool animate)
+{
+    m_topControls->updateState(constraint, current, animate);
+    m_layerTreeView->updateTopControlsState(constraint, current, animate);
 }
 
 void WebViewImpl::didUpdateTopControls()
 {
+    if (m_layerTreeView)
+        m_layerTreeView->setTopControlsShownRatio(m_topControls->shownRatio());
+
     WebLocalFrameImpl* mainFrame = mainFrameImpl();
     if (!mainFrame)
         return;
 
     FrameView* view = mainFrame->frameView();
     if (!view)
         return;
 
-    float topControlsViewportAdjustment = 0;
-    if (m_topControlsShrinkLayoutSize)
-        topControlsViewportAdjustment += m_topControlsHeight;
-    topControlsViewportAdjustment -= m_topControlsShownRatio * m_topControlsHeight;
+    float topControlsViewportAdjustment = m_topControls->layoutHeight() - m_topControls->contentOffset();
 
     if (!pinchVirtualViewportEnabled()) {
         // The viewport bounds were adjusted on the compositor by this much due to top controls. Tell
         // the FrameView about it so it can make correct scroll offset clamping decisions during compositor
         // commits.
         view->setTopControlsViewportAdjustment(topControlsViewportAdjustment);
     } else {
         PinchViewport& pinchViewport = page()->frameHost().pinchViewport();
 
         if (pinchViewport.visibleRect().isEmpty())
             return;
 
         pinchViewport.setTopControlsAdjustment(topControlsViewportAdjustment);
 
 // On ChromeOS the pinch viewport can change size independent of the layout viewport due to the
 // on screen keyboard so we should only set the FrameView adjustment on Android.
         if (settings() && settings()->mainFrameResizesAreOrientationChanges()) {
             // Shrink the FrameView by the amount that will maintain the aspect-ratio with the PinchViewport.
             float aspectRatio = pinchViewport.visibleRect().width() / pinchViewport.visibleRect().height();
             float newHeight = view->unscaledVisibleContentSize(ExcludeScrollbars).width() / aspectRatio;
             float adjustment = newHeight - view->unscaledVisibleContentSize(ExcludeScrollbars).height();
             view->setTopControlsViewportAdjustment(adjustment);
         }
     }
 }
 
+bool WebViewImpl::shouldTopControlsConsumeScroll(float scrollDeltaY)
+{
+    // Always consume if it's in the direction to show the top controls.
+    if (scrollDeltaY > 0)
+        return true;
+
+    if (mainFrame()->scrollOffset().height < mainFrame()->maximumScrollOffset().height)
+        return true;
+
+    return false;
+}
+
 void WebViewImpl::resize(const WebSize& newSize)
 {
     if (m_shouldAutoResize || m_size == newSize)
         return;
 
     WebLocalFrameImpl* mainFrame = mainFrameImpl();
     if (!mainFrame)
         return;
 
     FrameView* view = mainFrame->frameView();
@@ skipping 2633 matching lines @@
     float topControlsShownRatioDelta)
 {
     ASSERT(pinchVirtualViewportEnabled());
 
     if (!mainFrameImpl())
         return;
     FrameView* frameView = mainFrameImpl()->frameView();
     if (!frameView)
         return;
 
-    setTopControlsShownRatio(m_topControlsShownRatio + topControlsShownRatioDelta);
+    m_topControls->updateShownRatio(topControlsShownRatioDelta);
 
     FloatPoint pinchViewportOffset = page()->frameHost().pinchViewport().visibleRect().location();
     pinchViewportOffset.move(pinchViewportDelta.width, pinchViewportDelta.height);
     setPageScaleFactorAndLocation(pageScaleFactor() * pageScaleDelta, pinchViewportOffset);
 
     if (pageScaleDelta != 1)
         m_doubleTapZoomPending = false;
 
     frameView->setElasticOverscroll(elasticOverscrollDelta + frameView->elasticOverscroll());
 
     updateMainFrameScrollPosition(frameView->scrollableArea()->scrollPositionDouble() +
         DoubleSize(outerViewportDelta.width, outerViewportDelta.height), /* programmaticScroll */ false);
 }
 
 void WebViewImpl::applyViewportDeltas(const WebSize& scrollDelta, float pageScaleDelta, float topControlsShownRatioDelta)
 {
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return;
 
-    setTopControlsShownRatio(m_topControlsShownRatio + topControlsShownRatioDelta);
+    m_topControls->updateShownRatio(topControlsShownRatioDelta);
 
     if (pageScaleDelta == 1) {
         TRACE_EVENT_INSTANT2("blink", "WebViewImpl::applyScrollAndScale::scrollBy", "x", scrollDelta.width, "y", scrollDelta.height);
         WebSize webScrollOffset = mainFrame()->scrollOffset();
         IntPoint scrollOffset(webScrollOffset.width + scrollDelta.width, webScrollOffset.height + scrollDelta.height);
         updateMainFrameScrollPosition(scrollOffset, false);
     } else {
         // The page scale changed, so apply a scale and scroll in a single
         // operation.
         WebSize scrollOffset = mainFrame()->scrollOffset();
@@ skipping 159 matching lines @@
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 void WebViewImpl::forceNextWebGLContextCreationToFail()
 {
     WebGLRenderingContext::forceNextWebGLContextCreationToFail();
 }
 
 } // namespace blink