a8a6f4917b96d6f321a1b60a3e03d42858520f87
[WebKit-https.git] / Source / WebKit2 / UIProcess / mac / ViewGestureControllerMac.mm
1 /*
2  * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #import "config.h"
27 #import "ViewGestureController.h"
28
29 #if PLATFORM(MAC)
30
31 #import "FrameLoadState.h"
32 #import "NativeWebWheelEvent.h"
33 #import "ViewGestureControllerMessages.h"
34 #import "ViewGestureGeometryCollectorMessages.h"
35 #import "ViewSnapshotStore.h"
36 #import "WebBackForwardList.h"
37 #import "WebPageGroup.h"
38 #import "WebPageMessages.h"
39 #import "WebPageProxy.h"
40 #import "WebPreferences.h"
41 #import "WebProcessProxy.h"
42 #import <Cocoa/Cocoa.h>
43 #import <WebCore/IOSurface.h>
44 #import <WebCore/QuartzCoreSPI.h>
45 #import <WebCore/WebActionDisablingCALayerDelegate.h>
46
47 using namespace WebCore;
48
49 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101000
50 #define ENABLE_LEGACY_SWIPE_SHADOW_STYLE 1
51 #else
52 #define ENABLE_LEGACY_SWIPE_SHADOW_STYLE 0
53 #endif
54
55 static const double minMagnification = 1;
56 static const double maxMagnification = 3;
57
58 static const double minElasticMagnification = 0.75;
59 static const double maxElasticMagnification = 4;
60
61 static const double zoomOutBoost = 1.6;
62 static const double zoomOutResistance = 0.10;
63
64 static const float smartMagnificationElementPadding = 0.05;
65 static const float smartMagnificationPanScrollThreshold = 100;
66
67 #if ENABLE(LEGACY_SWIPE_SHADOW_STYLE)
68 static const double swipeOverlayShadowOpacity = 0.66;
69 static const double swipeOverlayShadowRadius = 3;
70 #else
71 static const double swipeOverlayShadowOpacity = 0.47;
72 static const double swipeOverlayDimmingOpacity = 0.12;
73 #endif
74
75 static const CGFloat minimumHorizontalSwipeDistance = 15;
76 static const float minimumScrollEventRatioForSwipe = 0.5;
77
78 static const float swipeSnapshotRemovalRenderTreeSizeTargetFraction = 0.5;
79 static const std::chrono::seconds swipeSnapshotRemovalWatchdogDuration = 5_s;
80 static const std::chrono::seconds swipeSnapshotRemovalWatchdogAfterFirstVisuallyNonEmptyLayoutDuration = 3_s;
81 static const std::chrono::milliseconds swipeSnapshotRemovalActiveLoadMonitoringInterval = 250_ms;
82
83 @interface WKSwipeCancellationTracker : NSObject {
84 @private
85     BOOL _isCancelled;
86 }
87
88 @property (nonatomic) BOOL isCancelled;
89
90 @end
91
92 @implementation WKSwipeCancellationTracker
93 @synthesize isCancelled=_isCancelled;
94 @end
95
96 namespace WebKit {
97
98 ViewGestureController::ViewGestureController(WebPageProxy& webPageProxy)
99     : m_webPageProxy(webPageProxy)
100     , m_swipeWatchdogTimer(RunLoop::main(), this, &ViewGestureController::swipeSnapshotWatchdogTimerFired)
101     , m_swipeActiveLoadMonitoringTimer(RunLoop::main(), this, &ViewGestureController::activeLoadMonitoringTimerFired)
102     , m_swipeWatchdogAfterFirstVisuallyNonEmptyLayoutTimer(RunLoop::main(), this, &ViewGestureController::swipeSnapshotWatchdogTimerFired)
103 {
104     m_webPageProxy.process().addMessageReceiver(Messages::ViewGestureController::messageReceiverName(), m_webPageProxy.pageID(), *this);
105 }
106
107 ViewGestureController::~ViewGestureController()
108 {
109     if (m_swipeCancellationTracker)
110         [m_swipeCancellationTracker setIsCancelled:YES];
111
112     if (m_activeGestureType == ViewGestureType::Swipe)
113         removeSwipeSnapshot();
114
115     if (m_didMoveSwipeSnapshotCallback) {
116         Block_release(m_didMoveSwipeSnapshotCallback);
117         m_didMoveSwipeSnapshotCallback = nullptr;
118     }
119
120     m_webPageProxy.process().removeMessageReceiver(Messages::ViewGestureController::messageReceiverName(), m_webPageProxy.pageID());
121 }
122
123 static double resistanceForDelta(double deltaScale, double currentScale)
124 {
125     // Zoom out with slight acceleration, until we reach minimum scale.
126     if (deltaScale < 0 && currentScale > minMagnification)
127         return zoomOutBoost;
128
129     // Zoom in with no acceleration, until we reach maximum scale.
130     if (deltaScale > 0 && currentScale < maxMagnification)
131         return 1;
132
133     // Outside of the extremes, resist further scaling.
134     double limit = currentScale < minMagnification ? minMagnification : maxMagnification;
135     double scaleDistance = fabs(limit - currentScale);
136     double scalePercent = std::min(std::max(scaleDistance / limit, 0.), 1.);
137     double resistance = zoomOutResistance + scalePercent * (0.01 - zoomOutResistance);
138
139     return resistance;
140 }
141
142 FloatPoint ViewGestureController::scaledMagnificationOrigin(FloatPoint origin, double scale)
143 {
144     FloatPoint scaledMagnificationOrigin(origin);
145     scaledMagnificationOrigin.moveBy(m_visibleContentRect.location());
146     float magnificationOriginScale = 1 - (scale / m_webPageProxy.pageScaleFactor());
147     scaledMagnificationOrigin.scale(magnificationOriginScale, magnificationOriginScale);
148     return scaledMagnificationOrigin;
149 }
150
151 void ViewGestureController::didCollectGeometryForMagnificationGesture(FloatRect visibleContentRect, bool frameHandlesMagnificationGesture)
152 {
153     m_activeGestureType = ViewGestureType::Magnification;
154     m_visibleContentRect = visibleContentRect;
155     m_visibleContentRectIsValid = true;
156     m_frameHandlesMagnificationGesture = frameHandlesMagnificationGesture;
157 }
158
159 void ViewGestureController::handleMagnificationGesture(double scale, FloatPoint origin)
160 {
161     ASSERT(m_activeGestureType == ViewGestureType::None || m_activeGestureType == ViewGestureType::Magnification);
162
163     if (m_activeGestureType == ViewGestureType::None) {
164         // FIXME: We drop the first frame of the gesture on the floor, because we don't have the visible content bounds yet.
165         m_magnification = m_webPageProxy.pageScaleFactor();
166         m_webPageProxy.process().send(Messages::ViewGestureGeometryCollector::CollectGeometryForMagnificationGesture(), m_webPageProxy.pageID());
167         m_lastMagnificationGestureWasSmartMagnification = false;
168
169         return;
170     }
171
172     // We're still waiting for the DidCollectGeometry callback.
173     if (!m_visibleContentRectIsValid)
174         return;
175
176     m_activeGestureType = ViewGestureType::Magnification;
177
178     double scaleWithResistance = resistanceForDelta(scale, m_magnification) * scale;
179
180     m_magnification += m_magnification * scaleWithResistance;
181     m_magnification = std::min(std::max(m_magnification, minElasticMagnification), maxElasticMagnification);
182
183     m_magnificationOrigin = origin;
184
185     if (m_frameHandlesMagnificationGesture)
186         m_webPageProxy.scalePage(m_magnification, roundedIntPoint(origin));
187     else
188         m_webPageProxy.drawingArea()->adjustTransientZoom(m_magnification, scaledMagnificationOrigin(origin, m_magnification));
189 }
190
191 void ViewGestureController::endMagnificationGesture()
192 {
193     if (m_activeGestureType != ViewGestureType::Magnification)
194         return;
195
196     double newMagnification = std::min(std::max(m_magnification, minMagnification), maxMagnification);
197
198     if (m_frameHandlesMagnificationGesture)
199         m_webPageProxy.scalePage(newMagnification, roundedIntPoint(m_magnificationOrigin));
200     else {
201         if (auto drawingArea = m_webPageProxy.drawingArea())
202             drawingArea->commitTransientZoom(newMagnification, scaledMagnificationOrigin(m_magnificationOrigin, newMagnification));
203     }
204
205     m_activeGestureType = ViewGestureType::None;
206     m_visibleContentRectIsValid = false;
207 }
208
209 void ViewGestureController::handleSmartMagnificationGesture(FloatPoint origin)
210 {
211     if (m_activeGestureType != ViewGestureType::None)
212         return;
213
214     m_webPageProxy.process().send(Messages::ViewGestureGeometryCollector::CollectGeometryForSmartMagnificationGesture(origin), m_webPageProxy.pageID());
215 }
216
217 static float maximumRectangleComponentDelta(FloatRect a, FloatRect b)
218 {
219     return std::max(fabs(a.x() - b.x()), std::max(fabs(a.y() - b.y()), std::max(fabs(a.width() - b.width()), fabs(a.height() - b.height()))));
220 }
221
222 void ViewGestureController::didCollectGeometryForSmartMagnificationGesture(FloatPoint origin, FloatRect renderRect, FloatRect visibleContentRect, bool isReplacedElement, double viewportMinimumScale, double viewportMaximumScale)
223 {
224     double currentScaleFactor = m_webPageProxy.pageScaleFactor();
225
226     FloatRect unscaledTargetRect = renderRect;
227
228     // If there was no usable element under the cursor, we'll scale towards the cursor instead.
229     if (unscaledTargetRect.isEmpty())
230         unscaledTargetRect.setLocation(origin);
231
232     unscaledTargetRect.scale(1 / currentScaleFactor);
233     unscaledTargetRect.inflateX(unscaledTargetRect.width() * smartMagnificationElementPadding);
234     unscaledTargetRect.inflateY(unscaledTargetRect.height() * smartMagnificationElementPadding);
235
236     double targetMagnification = visibleContentRect.width() / unscaledTargetRect.width();
237
238     FloatRect unscaledVisibleContentRect = visibleContentRect;
239     unscaledVisibleContentRect.scale(1 / currentScaleFactor);
240     FloatRect viewportConstrainedUnscaledTargetRect = unscaledTargetRect;
241     viewportConstrainedUnscaledTargetRect.intersect(unscaledVisibleContentRect);
242
243     if (unscaledTargetRect.width() > viewportConstrainedUnscaledTargetRect.width())
244         viewportConstrainedUnscaledTargetRect.setX(unscaledVisibleContentRect.x() + (origin.x() / currentScaleFactor) - viewportConstrainedUnscaledTargetRect.width() / 2);
245     if (unscaledTargetRect.height() > viewportConstrainedUnscaledTargetRect.height())
246         viewportConstrainedUnscaledTargetRect.setY(unscaledVisibleContentRect.y() + (origin.y() / currentScaleFactor) - viewportConstrainedUnscaledTargetRect.height() / 2);
247
248     // For replaced elements like images, we want to fit the whole element
249     // in the view, so scale it down enough to make both dimensions fit if possible.
250     if (isReplacedElement)
251         targetMagnification = std::min(targetMagnification, static_cast<double>(visibleContentRect.height() / viewportConstrainedUnscaledTargetRect.height()));
252
253     targetMagnification = std::min(std::max(targetMagnification, minMagnification), maxMagnification);
254
255     // Allow panning between elements via double-tap while magnified, unless the target rect is
256     // similar to the last one or the mouse has not moved, in which case we'll zoom all the way out.
257     if (currentScaleFactor > 1 && m_lastMagnificationGestureWasSmartMagnification) {
258         if (maximumRectangleComponentDelta(m_lastSmartMagnificationUnscaledTargetRect, unscaledTargetRect) < smartMagnificationPanScrollThreshold)
259             targetMagnification = 1;
260
261         if (m_lastSmartMagnificationOrigin == origin)
262             targetMagnification = 1;
263     }
264
265     FloatRect targetRect(viewportConstrainedUnscaledTargetRect);
266     targetRect.scale(targetMagnification);
267     FloatPoint targetOrigin(visibleContentRect.center());
268     targetOrigin.moveBy(-targetRect.center());
269
270     m_webPageProxy.drawingArea()->adjustTransientZoom(m_webPageProxy.pageScaleFactor(), scaledMagnificationOrigin(FloatPoint(), m_webPageProxy.pageScaleFactor()));
271     m_webPageProxy.drawingArea()->commitTransientZoom(targetMagnification, targetOrigin);
272
273     m_lastSmartMagnificationUnscaledTargetRect = unscaledTargetRect;
274     m_lastSmartMagnificationOrigin = origin;
275
276     m_lastMagnificationGestureWasSmartMagnification = true;
277 }
278
279 bool ViewGestureController::scrollEventCanBecomeSwipe(NSEvent *event, ViewGestureController::SwipeDirection& potentialSwipeDirection)
280 {
281     if (event.phase != NSEventPhaseBegan)
282         return false;
283
284     if (!event.hasPreciseScrollingDeltas)
285         return false;
286
287     if (![NSEvent isSwipeTrackingFromScrollEventsEnabled])
288         return false;
289
290     if (fabs(event.scrollingDeltaX) <= fabs(event.scrollingDeltaY))
291         return false;
292
293     bool isPinnedToLeft = m_shouldIgnorePinnedState || m_webPageProxy.isPinnedToLeftSide();
294     bool isPinnedToRight = m_shouldIgnorePinnedState || m_webPageProxy.isPinnedToRightSide();
295
296     bool willSwipeLeft = event.scrollingDeltaX > 0 && isPinnedToLeft && m_webPageProxy.backForwardList().backItem();
297     bool willSwipeRight = event.scrollingDeltaX < 0 && isPinnedToRight && m_webPageProxy.backForwardList().forwardItem();
298     if (!willSwipeLeft && !willSwipeRight)
299         return false;
300
301     potentialSwipeDirection = willSwipeLeft ? ViewGestureController::SwipeDirection::Back : ViewGestureController::SwipeDirection::Forward;
302
303     return true;
304 }
305
306 bool ViewGestureController::deltaIsSufficientToBeginSwipe(NSEvent *event)
307 {
308     if (m_pendingSwipeReason != PendingSwipeReason::InsufficientMagnitude)
309         return false;
310
311     m_cumulativeDeltaForPendingSwipe += FloatSize(event.scrollingDeltaX, event.scrollingDeltaY);
312
313     // If the cumulative delta is ever "too vertical", we will stop tracking this
314     // as a potential swipe until we get another "begin" event.
315     if (fabs(m_cumulativeDeltaForPendingSwipe.height()) >= fabs(m_cumulativeDeltaForPendingSwipe.width()) * minimumScrollEventRatioForSwipe) {
316         m_pendingSwipeReason = PendingSwipeReason::None;
317         return false;
318     }
319
320     if (fabs(m_cumulativeDeltaForPendingSwipe.width()) < minimumHorizontalSwipeDistance)
321         return false;
322
323     return true;
324 }
325
326 void ViewGestureController::setDidMoveSwipeSnapshotCallback(void(^callback)(CGRect))
327 {
328     if (m_didMoveSwipeSnapshotCallback)
329         Block_release(m_didMoveSwipeSnapshotCallback);
330     m_didMoveSwipeSnapshotCallback = Block_copy(callback);
331 }
332
333 bool ViewGestureController::handleScrollWheelEvent(NSEvent *event)
334 {
335     if (event.phase == NSEventPhaseEnded) {
336         m_cumulativeDeltaForPendingSwipe = FloatSize();
337         m_pendingSwipeReason = PendingSwipeReason::None;
338     }
339
340     if (m_pendingSwipeReason == PendingSwipeReason::InsufficientMagnitude) {
341         if (deltaIsSufficientToBeginSwipe(event)) {
342             trackSwipeGesture(event, m_pendingSwipeDirection);
343             return true;
344         }
345     }
346
347     if (m_activeGestureType != ViewGestureType::None)
348         return false;
349
350     SwipeDirection direction;
351     if (!scrollEventCanBecomeSwipe(event, direction))
352         return false;
353
354     if (!m_shouldIgnorePinnedState && m_webPageProxy.willHandleHorizontalScrollEvents()) {
355         m_pendingSwipeReason = PendingSwipeReason::WebCoreMayScroll;
356         m_pendingSwipeDirection = direction;
357         return false;
358     }
359
360     if (!deltaIsSufficientToBeginSwipe(event)) {
361         m_pendingSwipeReason = PendingSwipeReason::InsufficientMagnitude;
362         m_pendingSwipeDirection = direction;
363         return true;
364     }
365
366     trackSwipeGesture(event, direction);
367
368     return true;
369 }
370
371 void ViewGestureController::wheelEventWasNotHandledByWebCore(NSEvent *event)
372 {
373     if (m_pendingSwipeReason != PendingSwipeReason::WebCoreMayScroll)
374         return;
375
376     m_pendingSwipeReason = PendingSwipeReason::None;
377
378     SwipeDirection direction;
379     if (!scrollEventCanBecomeSwipe(event, direction))
380         return;
381
382     if (!deltaIsSufficientToBeginSwipe(event)) {
383         m_pendingSwipeReason = PendingSwipeReason::InsufficientMagnitude;
384         return;
385     }
386
387     trackSwipeGesture(event, m_pendingSwipeDirection);
388 }
389
390 void ViewGestureController::trackSwipeGesture(NSEvent *event, SwipeDirection direction)
391 {
392     ASSERT(m_activeGestureType == ViewGestureType::None);
393     m_pendingSwipeReason = PendingSwipeReason::None;
394
395     m_webPageProxy.recordNavigationSnapshot();
396
397     CGFloat maxProgress = (direction == SwipeDirection::Back) ? 1 : 0;
398     CGFloat minProgress = (direction == SwipeDirection::Forward) ? -1 : 0;
399     RefPtr<WebBackForwardListItem> targetItem = (direction == SwipeDirection::Back) ? m_webPageProxy.backForwardList().backItem() : m_webPageProxy.backForwardList().forwardItem();
400     if (!targetItem)
401         return;
402     
403     __block bool swipeCancelled = false;
404
405     ASSERT(!m_swipeCancellationTracker);
406     RetainPtr<WKSwipeCancellationTracker> swipeCancellationTracker = adoptNS([[WKSwipeCancellationTracker alloc] init]);
407     m_swipeCancellationTracker = swipeCancellationTracker;
408
409     [event trackSwipeEventWithOptions:0 dampenAmountThresholdMin:minProgress max:maxProgress usingHandler:^(CGFloat progress, NSEventPhase phase, BOOL isComplete, BOOL *stop) {
410         if ([swipeCancellationTracker isCancelled]) {
411             *stop = YES;
412             return;
413         }
414         if (phase == NSEventPhaseBegan)
415             this->beginSwipeGesture(targetItem.get(), direction);
416         CGFloat clampedProgress = std::min(std::max(progress, minProgress), maxProgress);
417         this->handleSwipeGesture(targetItem.get(), clampedProgress, direction);
418         if (phase == NSEventPhaseCancelled)
419             swipeCancelled = true;
420         if (isComplete)
421             this->endSwipeGesture(targetItem.get(), swipeCancelled);
422     }];
423 }
424
425 FloatRect ViewGestureController::windowRelativeBoundsForCustomSwipeViews() const
426 {
427     FloatRect swipeArea;
428     for (const auto& view : m_customSwipeViews)
429         swipeArea.unite([view convertRect:[view bounds] toView:nil]);
430     swipeArea.setHeight(swipeArea.height() - m_customSwipeViewsTopContentInset);
431     return swipeArea;
432 }
433
434 static CALayer *leastCommonAncestorLayer(const Vector<RetainPtr<CALayer>>& layers)
435 {
436     Vector<Vector<CALayer *>> liveLayerPathsFromRoot(layers.size());
437
438     size_t shortestPathLength = std::numeric_limits<size_t>::max();
439
440     for (size_t layerIndex = 0; layerIndex < layers.size(); layerIndex++) {
441         CALayer *parent = [layers[layerIndex] superlayer];
442         while (parent) {
443             liveLayerPathsFromRoot[layerIndex].insert(0, parent);
444             shortestPathLength = std::min(shortestPathLength, liveLayerPathsFromRoot[layerIndex].size());
445             parent = parent.superlayer;
446         }
447     }
448
449     for (size_t pathIndex = 0; pathIndex < shortestPathLength; pathIndex++) {
450         CALayer *firstPathLayer = liveLayerPathsFromRoot[0][pathIndex];
451         for (size_t layerIndex = 1; layerIndex < layers.size(); layerIndex++) {
452             if (liveLayerPathsFromRoot[layerIndex][pathIndex] != firstPathLayer)
453                 return firstPathLayer;
454         }
455     }
456
457     return liveLayerPathsFromRoot[0][shortestPathLength];
458 }
459
460 CALayer *ViewGestureController::determineSnapshotLayerParent() const
461 {
462     if (m_currentSwipeLiveLayers.size() == 1)
463         return [m_currentSwipeLiveLayers[0] superlayer];
464
465     // We insert our snapshot into the first shared superlayer of the custom views' layer, above the frontmost or below the bottommost layer.
466     return leastCommonAncestorLayer(m_currentSwipeLiveLayers);
467 }
468
469 CALayer *ViewGestureController::determineLayerAdjacentToSnapshotForParent(SwipeDirection direction, CALayer *snapshotLayerParent) const
470 {
471     // If we have custom swiping views, we assume that the views were passed to us in back-to-front z-order.
472     CALayer *layerAdjacentToSnapshot = direction == SwipeDirection::Back ? m_currentSwipeLiveLayers.first().get() : m_currentSwipeLiveLayers.last().get();
473
474     if (m_currentSwipeLiveLayers.size() == 1)
475         return layerAdjacentToSnapshot;
476
477     // If the layers are not all siblings, find the child of the layer we're going to insert the snapshot into which has the frontmost/bottommost layer as a child.
478     while (snapshotLayerParent != layerAdjacentToSnapshot.superlayer)
479         layerAdjacentToSnapshot = layerAdjacentToSnapshot.superlayer;
480     return layerAdjacentToSnapshot;
481 }
482
483 bool ViewGestureController::shouldUseSnapshotForSize(ViewSnapshot& snapshot, FloatSize swipeLayerSize, float topContentInset)
484 {
485     float deviceScaleFactor = m_webPageProxy.deviceScaleFactor();
486     if (snapshot.deviceScaleFactor() != deviceScaleFactor)
487         return false;
488
489     FloatSize unobscuredSwipeLayerSizeInDeviceCoordinates = swipeLayerSize - FloatSize(0, topContentInset);
490     unobscuredSwipeLayerSizeInDeviceCoordinates.scale(deviceScaleFactor);
491     if (snapshot.size() != unobscuredSwipeLayerSizeInDeviceCoordinates)
492         return false;
493
494     return true;
495 }
496
497 static bool layerGeometryFlippedToRoot(CALayer *layer)
498 {
499     bool flipped = false;
500     CALayer *parent = layer;
501     while (parent) {
502         if (parent.isGeometryFlipped)
503             flipped = !flipped;
504         parent = parent.superlayer;
505     }
506     return flipped;
507 }
508
509 void ViewGestureController::applyDebuggingPropertiesToSwipeViews()
510 {
511     CAFilter* filter = [CAFilter filterWithType:kCAFilterColorInvert];
512     [m_swipeLayer setFilters:@[ filter ]];
513     [m_swipeLayer setBackgroundColor:[NSColor blueColor].CGColor];
514     [m_swipeLayer setBorderColor:[NSColor yellowColor].CGColor];
515     [m_swipeLayer setBorderWidth:4];
516
517     [m_swipeSnapshotLayer setBackgroundColor:[NSColor greenColor].CGColor];
518     [m_swipeSnapshotLayer setBorderColor:[NSColor redColor].CGColor];
519     [m_swipeSnapshotLayer setBorderWidth:2];
520 }
521
522 void ViewGestureController::beginSwipeGesture(WebBackForwardListItem* targetItem, SwipeDirection direction)
523 {
524     ASSERT(m_currentSwipeLiveLayers.isEmpty());
525
526     m_webPageProxy.navigationGestureDidBegin();
527
528     m_activeGestureType = ViewGestureType::Swipe;
529     m_swipeInProgress = true;
530
531     CALayer *rootContentLayer = m_webPageProxy.acceleratedCompositingRootLayer();
532
533     m_swipeLayer = adoptNS([[CALayer alloc] init]);
534     m_swipeSnapshotLayer = adoptNS([[CALayer alloc] init]);
535     m_currentSwipeCustomViewBounds = windowRelativeBoundsForCustomSwipeViews();
536
537     FloatRect swipeArea;
538     float topContentInset = 0;
539     if (!m_customSwipeViews.isEmpty()) {
540         topContentInset = m_customSwipeViewsTopContentInset;
541         swipeArea = m_currentSwipeCustomViewBounds;
542         swipeArea.expand(0, topContentInset);
543
544         for (const auto& view : m_customSwipeViews) {
545             CALayer *layer = [view layer];
546             ASSERT(layer);
547             m_currentSwipeLiveLayers.append(layer);
548         }
549     } else {
550         swipeArea = FloatRect(FloatPoint(), m_webPageProxy.viewSize());
551         topContentInset = m_webPageProxy.topContentInset();
552         m_currentSwipeLiveLayers.append(rootContentLayer);
553     }
554
555     CALayer *snapshotLayerParent = determineSnapshotLayerParent();
556     bool geometryIsFlippedToRoot = layerGeometryFlippedToRoot(snapshotLayerParent);
557
558     RetainPtr<CGColorRef> backgroundColor = CGColorGetConstantColor(kCGColorWhite);
559     if (ViewSnapshot* snapshot = targetItem->snapshot()) {
560         if (shouldUseSnapshotForSize(*snapshot, swipeArea.size(), topContentInset))
561             [m_swipeSnapshotLayer setContents:snapshot->asLayerContents()];
562
563         Color coreColor = snapshot->backgroundColor();
564         if (coreColor.isValid())
565             backgroundColor = cachedCGColor(coreColor, ColorSpaceDeviceRGB);
566 #if USE_IOSURFACE_VIEW_SNAPSHOTS
567         m_currentSwipeSnapshot = snapshot;
568 #endif
569     }
570
571     [m_swipeLayer setBackgroundColor:backgroundColor.get()];
572     [m_swipeLayer setAnchorPoint:CGPointZero];
573     [m_swipeLayer setFrame:swipeArea];
574     [m_swipeLayer setName:@"Gesture Swipe Root Layer"];
575     [m_swipeLayer setGeometryFlipped:geometryIsFlippedToRoot];
576     [m_swipeLayer setDelegate:[WebActionDisablingCALayerDelegate shared]];
577
578     float deviceScaleFactor = m_webPageProxy.deviceScaleFactor();
579     [m_swipeSnapshotLayer setContentsGravity:kCAGravityTopLeft];
580     [m_swipeSnapshotLayer setContentsScale:deviceScaleFactor];
581     [m_swipeSnapshotLayer setAnchorPoint:CGPointZero];
582     [m_swipeSnapshotLayer setFrame:CGRectMake(0, 0, swipeArea.width(), swipeArea.height() - topContentInset)];
583     [m_swipeSnapshotLayer setName:@"Gesture Swipe Snapshot Layer"];
584     [m_swipeSnapshotLayer setDelegate:[WebActionDisablingCALayerDelegate shared]];
585
586     [m_swipeLayer addSublayer:m_swipeSnapshotLayer.get()];
587
588     if (m_webPageProxy.preferences().viewGestureDebuggingEnabled())
589         applyDebuggingPropertiesToSwipeViews();
590
591
592     CALayer *layerAdjacentToSnapshot = determineLayerAdjacentToSnapshotForParent(direction, snapshotLayerParent);
593     if (direction == SwipeDirection::Back)
594         [snapshotLayerParent insertSublayer:m_swipeLayer.get() below:layerAdjacentToSnapshot];
595     else
596         [snapshotLayerParent insertSublayer:m_swipeLayer.get() above:layerAdjacentToSnapshot];
597
598     // We don't know enough about the custom views' hierarchy to apply a shadow.
599     if (m_swipeTransitionStyle == SwipeTransitionStyle::Overlap && m_customSwipeViews.isEmpty()) {
600 #if ENABLE(LEGACY_SWIPE_SHADOW_STYLE)
601         if (direction == SwipeDirection::Back) {
602             float topContentInset = m_webPageProxy.topContentInset();
603             FloatRect shadowRect(FloatPoint(0, topContentInset), m_webPageProxy.viewSize() - FloatSize(0, topContentInset));
604             RetainPtr<CGPathRef> shadowPath = adoptCF(CGPathCreateWithRect(shadowRect, 0));
605             [rootContentLayer setShadowColor:CGColorGetConstantColor(kCGColorBlack)];
606             [rootContentLayer setShadowOpacity:swipeOverlayShadowOpacity];
607             [rootContentLayer setShadowRadius:swipeOverlayShadowRadius];
608             [rootContentLayer setShadowPath:shadowPath.get()];
609         } else {
610             RetainPtr<CGPathRef> shadowPath = adoptCF(CGPathCreateWithRect([m_swipeLayer bounds], 0));
611             [m_swipeLayer setShadowColor:CGColorGetConstantColor(kCGColorBlack)];
612             [m_swipeLayer setShadowOpacity:swipeOverlayShadowOpacity];
613             [m_swipeLayer setShadowRadius:swipeOverlayShadowRadius];
614             [m_swipeLayer setShadowPath:shadowPath.get()];
615         }
616 #else
617         FloatRect dimmingRect(FloatPoint(), m_webPageProxy.viewSize());
618         m_swipeDimmingLayer = adoptNS([[CALayer alloc] init]);
619         [m_swipeDimmingLayer setName:@"Gesture Swipe Dimming Layer"];
620         [m_swipeDimmingLayer setBackgroundColor:[NSColor blackColor].CGColor];
621         [m_swipeDimmingLayer setOpacity:swipeOverlayDimmingOpacity];
622         [m_swipeDimmingLayer setAnchorPoint:CGPointZero];
623         [m_swipeDimmingLayer setFrame:dimmingRect];
624         [m_swipeDimmingLayer setGeometryFlipped:geometryIsFlippedToRoot];
625         [m_swipeDimmingLayer setDelegate:[WebActionDisablingCALayerDelegate shared]];
626
627         NSImage *shadowImage = [[NSBundle bundleForClass:[WKSwipeCancellationTracker class]] imageForResource:@"SwipeShadow"];
628         FloatRect shadowRect(-shadowImage.size.width, topContentInset, shadowImage.size.width, m_webPageProxy.viewSize().height() - topContentInset);
629         m_swipeShadowLayer = adoptNS([[CALayer alloc] init]);
630         [m_swipeShadowLayer setName:@"Gesture Swipe Shadow Layer"];
631         [m_swipeShadowLayer setBackgroundColor:[NSColor colorWithPatternImage:shadowImage].CGColor];
632         [m_swipeShadowLayer setContentsScale:deviceScaleFactor];
633         [m_swipeShadowLayer setOpacity:swipeOverlayShadowOpacity];
634         [m_swipeShadowLayer setAnchorPoint:CGPointZero];
635         [m_swipeShadowLayer setFrame:shadowRect];
636         [m_swipeShadowLayer setGeometryFlipped:geometryIsFlippedToRoot];
637         [m_swipeShadowLayer setDelegate:[WebActionDisablingCALayerDelegate shared]];
638
639         if (direction == SwipeDirection::Back)
640             [snapshotLayerParent insertSublayer:m_swipeDimmingLayer.get() above:m_swipeLayer.get()];
641         else
642             [snapshotLayerParent insertSublayer:m_swipeDimmingLayer.get() below:m_swipeLayer.get()];
643
644         [snapshotLayerParent insertSublayer:m_swipeShadowLayer.get() above:m_swipeLayer.get()];
645 #endif
646     }
647 }
648
649 void ViewGestureController::handleSwipeGesture(WebBackForwardListItem* targetItem, double progress, SwipeDirection direction)
650 {
651     ASSERT(m_activeGestureType == ViewGestureType::Swipe);
652
653     if (!m_webPageProxy.drawingArea())
654         return;
655
656     double width;
657     if (!m_customSwipeViews.isEmpty())
658         width = m_currentSwipeCustomViewBounds.width();
659     else
660         width = m_webPageProxy.drawingArea()->size().width();
661
662     double swipingLayerOffset = floor(width * progress);
663
664 #if !ENABLE(LEGACY_SWIPE_SHADOW_STYLE)
665     double dimmingProgress = (direction == SwipeDirection::Back) ? 1 - progress : -progress;
666     dimmingProgress = std::min(1., std::max(dimmingProgress, 0.));
667     [m_swipeDimmingLayer setOpacity:dimmingProgress * swipeOverlayDimmingOpacity];
668
669     double absoluteProgress = fabs(progress);
670     double remainingSwipeDistance = width - fabs(absoluteProgress * width);
671     double shadowFadeDistance = [m_swipeShadowLayer bounds].size.width;
672     if (remainingSwipeDistance < shadowFadeDistance)
673         [m_swipeShadowLayer setOpacity:(remainingSwipeDistance / shadowFadeDistance) * swipeOverlayShadowOpacity];
674     else
675         [m_swipeShadowLayer setOpacity:swipeOverlayShadowOpacity];
676
677     if (m_swipeTransitionStyle == SwipeTransitionStyle::Overlap)
678         [m_swipeShadowLayer setTransform:CATransform3DMakeTranslation((direction == SwipeDirection::Back ? 0 : width) + swipingLayerOffset, 0, 0)];
679 #endif
680
681     if (m_swipeTransitionStyle == SwipeTransitionStyle::Overlap) {
682         if (direction == SwipeDirection::Forward) {
683             [m_swipeLayer setTransform:CATransform3DMakeTranslation(width + swipingLayerOffset, 0, 0)];
684             didMoveSwipeSnapshotLayer();
685         }
686     } else if (m_swipeTransitionStyle == SwipeTransitionStyle::Push)
687         [m_swipeLayer setTransform:CATransform3DMakeTranslation((direction == SwipeDirection::Back ? -width : width) + swipingLayerOffset, 0, 0)];
688
689     for (const auto& layer : m_currentSwipeLiveLayers) {
690         if (m_swipeTransitionStyle == SwipeTransitionStyle::Overlap) {
691             if (direction == SwipeDirection::Back)
692                 [layer setTransform:CATransform3DMakeTranslation(swipingLayerOffset, 0, 0)];
693         } else if (m_swipeTransitionStyle == SwipeTransitionStyle::Push)
694             [layer setTransform:CATransform3DMakeTranslation(swipingLayerOffset, 0, 0)];
695     }
696 }
697
698 void ViewGestureController::didMoveSwipeSnapshotLayer()
699 {
700     if (!m_didMoveSwipeSnapshotCallback)
701         return;
702
703     m_didMoveSwipeSnapshotCallback(m_webPageProxy.boundsOfLayerInLayerBackedWindowCoordinates(m_swipeLayer.get()));
704 }
705
706 void ViewGestureController::endSwipeGesture(WebBackForwardListItem* targetItem, bool cancelled)
707 {
708     ASSERT(m_activeGestureType == ViewGestureType::Swipe);
709
710     m_swipeCancellationTracker = nullptr;
711
712     m_swipeInProgress = false;
713
714     CALayer *rootLayer = m_webPageProxy.acceleratedCompositingRootLayer();
715
716     [rootLayer setShadowOpacity:0];
717     [rootLayer setShadowRadius:0];
718
719     if (cancelled) {
720         removeSwipeSnapshot();
721         m_webPageProxy.navigationGestureDidEnd(false, *targetItem);
722         return;
723     }
724
725     uint64_t renderTreeSize = 0;
726     if (ViewSnapshot* snapshot = targetItem->snapshot())
727         renderTreeSize = snapshot->renderTreeSize();
728
729     m_webPageProxy.process().send(Messages::ViewGestureGeometryCollector::SetRenderTreeSizeNotificationThreshold(renderTreeSize * swipeSnapshotRemovalRenderTreeSizeTargetFraction), m_webPageProxy.pageID());
730
731     m_swipeWaitingForVisuallyNonEmptyLayout = true;
732     m_swipeWaitingForRenderTreeSizeThreshold = true;
733
734     m_webPageProxy.navigationGestureDidEnd(true, *targetItem);
735     m_webPageProxy.goToBackForwardItem(targetItem);
736
737     // FIXME: Like on iOS, we should ensure that even if one of the timeouts fires,
738     // we never show the old page content, instead showing white (or the snapshot background color).
739     m_swipeWatchdogTimer.startOneShot(swipeSnapshotRemovalWatchdogDuration.count());
740
741     if (ViewSnapshot* snapshot = targetItem->snapshot())
742         m_backgroundColorForCurrentSnapshot = snapshot->backgroundColor();
743 }
744
745 void ViewGestureController::didHitRenderTreeSizeThreshold()
746 {
747     if (m_activeGestureType != ViewGestureType::Swipe || m_swipeInProgress)
748         return;
749
750     m_swipeWaitingForRenderTreeSizeThreshold = false;
751
752     if (!m_swipeWaitingForVisuallyNonEmptyLayout) {
753         // FIXME: Ideally we would call removeSwipeSnapshotAfterRepaint() here, but sometimes
754         // scroll position isn't done restoring until didFinishLoadForFrame, so we flash the wrong content.
755     }
756 }
757
758 void ViewGestureController::didFirstVisuallyNonEmptyLayoutForMainFrame()
759 {
760     if (m_activeGestureType != ViewGestureType::Swipe || m_swipeInProgress)
761         return;
762
763     m_swipeWaitingForVisuallyNonEmptyLayout = false;
764
765     if (!m_swipeWaitingForRenderTreeSizeThreshold) {
766         // FIXME: Ideally we would call removeSwipeSnapshotAfterRepaint() here, but sometimes
767         // scroll position isn't done restoring until didFinishLoadForFrame, so we flash the wrong content.
768     } else {
769         m_swipeWatchdogAfterFirstVisuallyNonEmptyLayoutTimer.startOneShot(swipeSnapshotRemovalWatchdogAfterFirstVisuallyNonEmptyLayoutDuration.count());
770         m_swipeWatchdogTimer.stop();
771     }
772 }
773
774 void ViewGestureController::didFinishLoadForMainFrame()
775 {
776     if (m_activeGestureType != ViewGestureType::Swipe || m_swipeInProgress)
777         return;
778
779     if (m_webPageProxy.pageLoadState().isLoading()) {
780         m_swipeActiveLoadMonitoringTimer.startRepeating(swipeSnapshotRemovalActiveLoadMonitoringInterval);
781         return;
782     }
783
784     removeSwipeSnapshotAfterRepaint();
785 }
786
787 void ViewGestureController::didSameDocumentNavigationForMainFrame(SameDocumentNavigationType type)
788 {
789     if (m_activeGestureType != ViewGestureType::Swipe || m_swipeInProgress)
790         return;
791
792     if (type != SameDocumentNavigationSessionStateReplace && type != SameDocumentNavigationSessionStatePop)
793         return;
794
795     m_swipeActiveLoadMonitoringTimer.startRepeating(swipeSnapshotRemovalActiveLoadMonitoringInterval);
796 }
797
798 void ViewGestureController::activeLoadMonitoringTimerFired()
799 {
800     if (m_webPageProxy.pageLoadState().isLoading())
801         return;
802
803     removeSwipeSnapshotAfterRepaint();
804 }
805
806 void ViewGestureController::swipeSnapshotWatchdogTimerFired()
807 {
808     removeSwipeSnapshotAfterRepaint();
809 }
810
811 void ViewGestureController::removeSwipeSnapshotAfterRepaint()
812 {
813     m_swipeActiveLoadMonitoringTimer.stop();
814
815     if (m_activeGestureType != ViewGestureType::Swipe || m_swipeInProgress)
816         return;
817
818     if (m_swipeWaitingForRepaint)
819         return;
820
821     m_swipeWaitingForRepaint = true;
822
823     WebPageProxy* webPageProxy = &m_webPageProxy;
824     m_webPageProxy.forceRepaint(VoidCallback::create([webPageProxy] (CallbackBase::Error error) {
825         webPageProxy->removeNavigationGestureSnapshot();
826     }));
827 }
828
829 void ViewGestureController::removeSwipeSnapshot()
830 {
831     m_swipeWaitingForRepaint = false;
832
833     m_swipeWatchdogTimer.stop();
834     m_swipeWatchdogAfterFirstVisuallyNonEmptyLayoutTimer.stop();
835
836     if (m_activeGestureType != ViewGestureType::Swipe)
837         return;
838
839 #if USE_IOSURFACE_VIEW_SNAPSHOTS
840     if (m_currentSwipeSnapshot && m_currentSwipeSnapshot->surface())
841         m_currentSwipeSnapshot->surface()->setIsVolatile(true);
842     m_currentSwipeSnapshot = nullptr;
843 #endif
844
845     for (const auto& layer : m_currentSwipeLiveLayers)
846         [layer setTransform:CATransform3DIdentity];
847
848     [m_swipeSnapshotLayer removeFromSuperlayer];
849     m_swipeSnapshotLayer = nullptr;
850
851     [m_swipeLayer removeFromSuperlayer];
852     m_swipeLayer = nullptr;
853
854 #if !ENABLE(LEGACY_SWIPE_SHADOW_STYLE)
855     [m_swipeShadowLayer removeFromSuperlayer];
856     m_swipeShadowLayer = nullptr;
857
858     [m_swipeDimmingLayer removeFromSuperlayer];
859     m_swipeDimmingLayer = nullptr;
860 #endif
861
862     m_currentSwipeLiveLayers.clear();
863
864     m_activeGestureType = ViewGestureType::None;
865
866     m_webPageProxy.navigationGestureSnapshotWasRemoved();
867
868     m_backgroundColorForCurrentSnapshot = Color();
869 }
870
871 double ViewGestureController::magnification() const
872 {
873     if (m_activeGestureType == ViewGestureType::Magnification)
874         return m_magnification;
875
876     return m_webPageProxy.pageScaleFactor();
877 }
878
879 } // namespace WebKit
880
881 #endif // !PLATFORM(IOS)