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)