Implemented fullscreen exit animation with AppKit

chrome/browser/ui/cocoa/browser_window_fullscreen_transition.mm

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#import "chrome/browser/ui/cocoa/browser_window_enter_fullscreen_transition.h"
+#import "chrome/browser/ui/cocoa/browser_window_fullscreen_transition.h"
 
 #include <QuartzCore/QuartzCore.h>
 
-#include "base/mac/scoped_cftyperef.h"
-#include "base/mac/scoped_nsobject.h"
-#include "base/mac/sdk_forward_declarations.h"
+#include "base/mac/bind_objc_block.h"
+#include "base/mac/foundation_util.h"
+#include "base/mac/mac_util.h"
+#import "base/mac/scoped_nsobject.h"
+#import "base/mac/sdk_forward_declarations.h"
+#include "base/memory/scoped_ptr.h"
+#import "chrome/browser/ui/cocoa/framed_browser_window.h"
+#import "chrome/browser/ui/cocoa/full_size_content_window.h"
 
 namespace {
 
 NSString* const kPrimaryWindowAnimationID = @"PrimaryWindowAnimationID";
 NSString* const kSnapshotWindowAnimationID = @"SnapshotWindowAnimationID";
 NSString* const kAnimationIDKey = @"AnimationIDKey";
 
 // This class has two simultaneous animations to resize and reposition layers.
 // These animations must use the same timing function, otherwise there will be
 // visual discordance.
 NSString* TransformAnimationTimingFunction() {
   return kCAMediaTimingFunctionEaseInEaseOut;
 }
 
+// This class locks and unlocks the FrameBrowserWindow. Its destructor
+// ensures that the lock gets released.
+class FrameAndStyleLock {
+ public:
+  FrameAndStyleLock(FramedBrowserWindow* window) {
+    window_.reset([window retain]);
+  }
+
+  void setLock(bool lock) { [window_ setFrameAndStyleMaskLock:lock]; }
+
+  ~FrameAndStyleLock() { setLock(NO); }
+
+ private:
+  base::scoped_nsobject<FramedBrowserWindow> window_;
+};
+
 }  // namespace
 
-@interface BrowserWindowEnterFullscreenTransition () {
+@interface BrowserWindowFullscreenTransition () {
+  // Flag to keep track of whether we are entering or exiting full screen
+  BOOL isEnteringFullscreen_;
+
   // The window which is undergoing the fullscreen transition.
-  base::scoped_nsobject<NSWindow> primaryWindow_;
+  base::scoped_nsobject<FramedBrowserWindow> primaryWindow_;
 
   // A layer that holds a snapshot of the original state of |primaryWindow_|.
   base::scoped_nsobject<CALayer> snapshotLayer_;
 
   // A temporary window that holds |snapshotLayer_|.
   base::scoped_nsobject<NSWindow> snapshotWindow_;
 
-  // The frame of the |primaryWindow_| before the transition began.
-  NSRect primaryWindowInitialFrame_;
-
   // The background color of |primaryWindow_| before the transition began.
   base::scoped_nsobject<NSColor> primaryWindowInitialBackgroundColor_;
 
   // Whether |primaryWindow_| was opaque before the transition began.
   BOOL primaryWindowInitialOpaque_;
 
   // Whether the instance is in the process of changing the size of
   // |primaryWindow_|.
   BOOL changingPrimaryWindowSize_;
 
+  // The frame of the |primaryWindow_| before it starts the transition.
+  NSRect initialFrame_;
+
+  // A frame that represents the value of the |initialFrame_| that's relative
+  // to the current screen coordinates.

[erikchen, 2015/08/12 22:08:52]

It looks like initialFrameRelativeToScreen_ is used as the frame of the root
layer at t=0 (which is always relative to the NSWindow). I would say:

"""
// At the beginning of the exit fullscreen animation, the root layer of the
window is immediately moved and resized to match its expected frame at the end
of the animation. This ivar represents that frame in the coordinate system of
the NSWindow, while the NSWindow is still the same size as the screen.
"""

[spqchan1, 2015/08/13 20:38:48]

Done. I modified the name so that it's less confusing now

+  NSRect initialFrameRelativeToScreen_;

[erikchen, 2015/08/12 22:08:52]

If this ivar is only used for the exit animation, you should add a comment to
that effect.

[spqchan1, 2015/08/13 20:38:48]

Done.

+
   // The frame that |primaryWindow_| is expected to have after the transition
   // is finished.
-  NSRect primaryWindowFinalFrame_;
+  NSRect finalFrame_;
+
+  // Locks and unlocks the FullSizeContentWindow.
+  scoped_ptr<FrameAndStyleLock> lock_;
 }
 
 // Takes a snapshot of |primaryWindow_| and puts it in |snapshotLayer_|.
 - (void)takeSnapshot;
 
 // Creates |snapshotWindow_| and adds |snapshotLayer_| to it.
 - (void)makeAndPrepareSnapshotWindow;
 
 // This method has several effects on |primaryWindow_|:
 //  - Saves current state.
 //  - Makes window transparent, with clear background.
-//  - Adds NSFullScreenWindowMask style mask.
-//  - Sets the size to the screen's size.
+//  - If we are entering fullscreen, it will also:
+//    - Add NSFullScreenWindowMask style mask.
+//    - Set the size to the screen's size.
 - (void)preparePrimaryWindowForAnimation;
 
 // Applies the fullscreen animation to |snapshotLayer_|.
 - (void)animateSnapshotWindowWithDuration:(CGFloat)duration;
 
-// Applies the fullscreen animation to the root layer of |primaryWindow_|.
-- (void)animatePrimaryWindowWithDuration:(CGFloat)duration;
+// Sets |primaryWindow_|'s frame to the expected frame.
+- (void)changePrimaryWindowToFinalFrame;
 
 // Override of CAAnimation delegate method.
 - (void)animationDidStop:(CAAnimation*)theAnimation finished:(BOOL)flag;
 
 // Returns the layer of the root view of |window|.
 - (CALayer*)rootLayerOfWindow:(NSWindow*)window;
 
 @end
 
-@implementation BrowserWindowEnterFullscreenTransition
+@implementation BrowserWindowFullscreenTransition
 
 // -------------------------Public Methods----------------------------
 
-- (instancetype)initWithWindow:(NSWindow*)window {
+- (instancetype)initEnterWithWindow:(FramedBrowserWindow*)window {
   DCHECK(window);
   DCHECK([self rootLayerOfWindow:window]);
   if ((self = [super init])) {
     primaryWindow_.reset([window retain]);
+
+    isEnteringFullscreen_ = YES;
+    initialFrame_ = [primaryWindow_ frame];
+    finalFrame_ = [[primaryWindow_ screen] frame];
   }
   return self;
 }
 
-- (NSArray*)customWindowsToEnterFullScreen {
+- (instancetype)initExitWithWindow:(FramedBrowserWindow*)window
+                             frame:(NSRect)frame {
+  DCHECK(window);
+  DCHECK([self rootLayerOfWindow:window]);
+  if ((self = [super init])) {
+    primaryWindow_.reset([window retain]);
+
+    isEnteringFullscreen_ = NO;
+    finalFrame_ = frame;
+    initialFrame_ = [[primaryWindow_ screen] frame];
+
+    // Calculate the inital frame that is relative to coordinates of the
+    // screen which it's on.
+    initialFrameRelativeToScreen_ = finalFrame_;
+    CGFloat screenOriginX = finalFrame_.origin.x - initialFrame_.origin.x;
+    CGFloat screenOriginY = finalFrame_.origin.y - initialFrame_.origin.y;
+    initialFrameRelativeToScreen_.origin =
+        CGPointMake(screenOriginX, screenOriginY);
+
+    lock_.reset(new FrameAndStyleLock(window));
+  }
+  return self;
+}
+
+- (NSArray*)customWindowsForFullScreenTransition {
   [self takeSnapshot];
   [self makeAndPrepareSnapshotWindow];
-  [self preparePrimaryWindowForAnimation];
   return @[ primaryWindow_.get(), snapshotWindow_.get() ];
 }
 
-- (void)startCustomAnimationToEnterFullScreenWithDuration:
-    (NSTimeInterval)duration {
+// Right before the animation begins, change the content view size
+// and lock the primary window so that OSX can't make changes to it

[erikchen, 2015/08/12 22:08:52]

The lock only happens for the exit animation, right?

[spqchan1, 2015/08/13 20:38:48]

Done. Moved this comment to the inside of preparePrimaryWindowForAnimation

+// before we finish the animation.
+- (void)startCustomFullScreenAnimationWithDuration:(NSTimeInterval)duration {
+  [self preparePrimaryWindowForAnimation];
+  [self animatePrimaryWindowWithDuration:duration];
   [self animateSnapshotWindowWithDuration:duration];
-  [self animatePrimaryWindowWithDuration:duration];
 }
 
 - (BOOL)shouldWindowBeUnconstrained {
   return changingPrimaryWindowSize_;
 }
 
+- (NSSize)getDesiredWindowLayoutSize {
+  return (isEnteringFullscreen_) ? [primaryWindow_ frame].size
+                                 : [[primaryWindow_ contentView] bounds].size;
+}
+
 // -------------------------Private Methods----------------------------
 
 - (void)takeSnapshot {
   base::ScopedCFTypeRef<CGImageRef> windowSnapshot(CGWindowListCreateImage(
       CGRectNull, kCGWindowListOptionIncludingWindow,
       [primaryWindow_ windowNumber], kCGWindowImageBoundsIgnoreFraming));
   snapshotLayer_.reset([[CALayer alloc] init]);
   [snapshotLayer_ setFrame:NSRectToCGRect([primaryWindow_ frame])];
   [snapshotLayer_ setContents:static_cast<id>(windowSnapshot.get())];
   [snapshotLayer_ setAnchorPoint:CGPointMake(0, 0)];
   CGColorRef colorRef = CGColorCreateGenericRGB(0, 0, 0, 0);
   [snapshotLayer_ setBackgroundColor:colorRef];
   CGColorRelease(colorRef);
 }
 
 - (void)makeAndPrepareSnapshotWindow {
   DCHECK(snapshotLayer_);
 
-  snapshotWindow_.reset(
-      [[NSWindow alloc] initWithContentRect:[[primaryWindow_ screen] frame]
-                                  styleMask:0
-                                    backing:NSBackingStoreBuffered
-                                      defer:NO]);
+  snapshotWindow_.reset([[NSWindow alloc]
+      initWithContentRect:[[primaryWindow_ screen] frame]
+                styleMask:0
+                  backing:NSBackingStoreBuffered
+                    defer:NO]);
   [[snapshotWindow_ contentView] setWantsLayer:YES];
   [snapshotWindow_ setOpaque:NO];
   [snapshotWindow_ setBackgroundColor:[NSColor clearColor]];
   [snapshotWindow_ setAnimationBehavior:NSWindowAnimationBehaviorNone];
 
-  [snapshotWindow_ orderFront:nil];
   [[[snapshotWindow_ contentView] layer] addSublayer:snapshotLayer_];
 
   // Compute the frame of the snapshot layer such that the snapshot is
   // positioned exactly on top of the original position of |primaryWindow_|.
   NSRect snapshotLayerFrame =
       [snapshotWindow_ convertRectFromScreen:[primaryWindow_ frame]];
   [snapshotLayer_ setFrame:snapshotLayerFrame];
 }
 
 - (void)preparePrimaryWindowForAnimation {
-  // Save initial state of |primaryWindow_|.
-  primaryWindowInitialFrame_ = [primaryWindow_ frame];
+  // Save the initial state of the primary window.
   primaryWindowInitialBackgroundColor_.reset(
       [[primaryWindow_ backgroundColor] copy]);
   primaryWindowInitialOpaque_ = [primaryWindow_ isOpaque];
 
-  primaryWindowFinalFrame_ = [[primaryWindow_ screen] frame];
+  [primaryWindow_ setOpaque:NO];
 
-  // Make |primaryWindow_| invisible. This must happen before the window is

[erikchen, 2015/08/12 22:08:52]

Why did you remove these comments?

[spqchan1, 2015/08/13 20:38:48]

Whoops, these were accidentally removed when I was recombining the two classes.
Added them back

-  // resized, since resizing the window will call drawRect: and cause content
-  // to flash over the entire screen.
-  [primaryWindow_ setOpaque:NO];
-  [primaryWindow_ setBackgroundColor:[NSColor clearColor]];
-  CALayer* rootLayer = [self rootLayerOfWindow:primaryWindow_];
-  rootLayer.opacity = 0;
+  CALayer* root = [self rootLayerOfWindow:primaryWindow_];
+  root.opacity = 0;
+  root.frame = initialFrameRelativeToScreen_;

[erikchen, 2015/08/12 22:08:52]

The enter animation didn't need to set the root's frame. You've changed that
behavior. Why?

(It looks like initialFrameRelativeToScreen_ isn't even initialized for the
enterAnimation).

[spqchan1, 2015/08/13 20:38:48]

This should only be used for the exit animation. I added a check for this. 

This oversight didn't affect the enter animation because in the code, after
setting the root frame, the primaryWindow's frame is set to the finalFrame. This
automatically sets the layer's frame to the new one.

 
-  // As soon as the style mask includes the flag NSFullScreenWindowMask, the
-  // window is expected to receive fullscreen layout. This must be set before
-  // the window is resized, as that causes a relayout.
-  [primaryWindow_
-      setStyleMask:[primaryWindow_ styleMask] | NSFullScreenWindowMask];
-
-  // Resize |primaryWindow_|.
-  changingPrimaryWindowSize_ = YES;
-  [primaryWindow_ setFrame:primaryWindowFinalFrame_ display:YES];
-  changingPrimaryWindowSize_ = NO;
+  if (isEnteringFullscreen_) {
+    [primaryWindow_
+        setStyleMask:[primaryWindow_ styleMask] | NSFullScreenWindowMask];
+    [self changePrimaryWindowToFinalFrame];
+  } else {
+    FullSizeContentView* content =
+        base::mac::ObjCCast<FullSizeContentView>([primaryWindow_ contentView]);
+    [content forceFrameSize:finalFrame_.size];
+    lock_->setLock(YES);
+  }
 }
 
 - (void)animateSnapshotWindowWithDuration:(CGFloat)duration {
-  // Move the snapshot layer until it's bottom-left corner is at the
-  // bottom-left corner of the screen.
+  [snapshotWindow_ orderFront:nil];

[erikchen, 2015/08/12 22:08:52]

Why did you move this from makeAndPrepareSnapshotWindow?

[spqchan1, 2015/08/13 20:38:48]

I moved this out of makeAndPrepareSnapshotWindow because it doesn't work in exit
animation. In makeAndPrepareSnapshotWindow, snapshotWindow cannot move in front
of primaryWindow because primaryWindow is in fullscreen. As a result, it
orderedFront will have to placed at the beginning of the exit transition.

I decided to move it to animateSnapshotWindowWithDuration for both enter and
exit animation so that it's simpler to read. 

Alternatively, I can look into manually setting the levels (maybe setting
snapshotWindow level to CGShieldingWindowLevel). However, the NSWindow
documentation mentioned about being careful with doing this

+
+  // Calculate the frame so that it's relative to the screen
+  NSRect finalFrameRelativeToScreen =
+      [snapshotWindow_ convertRectFromScreen:finalFrame_];
+
   CABasicAnimation* positionAnimation =
       [CABasicAnimation animationWithKeyPath:@"position"];
-  positionAnimation.toValue = [NSValue valueWithPoint:NSZeroPoint];
+  positionAnimation.toValue =
+      [NSValue valueWithPoint:finalFrameRelativeToScreen.origin];
   positionAnimation.timingFunction = [CAMediaTimingFunction
       functionWithName:TransformAnimationTimingFunction()];
 
-  // Expand the bounds until it covers the screen.
-  NSRect finalBounds = NSMakeRect(0, 0, NSWidth(primaryWindowFinalFrame_),
-                                  NSHeight(primaryWindowFinalFrame_));
+  // Resize the bounds until it reaches the expected size at the end of the
+  // animation.
+  NSRect finalBounds =
+      NSMakeRect(0, 0, NSWidth(finalFrame_), NSHeight(finalFrame_));
   CABasicAnimation* boundsAnimation =
       [CABasicAnimation animationWithKeyPath:@"bounds"];
   boundsAnimation.toValue = [NSValue valueWithRect:finalBounds];
   boundsAnimation.timingFunction = [CAMediaTimingFunction
       functionWithName:TransformAnimationTimingFunction()];
 
   // Fade out the snapshot layer.
   CABasicAnimation* opacityAnimation =
       [CABasicAnimation animationWithKeyPath:@"opacity"];
   opacityAnimation.toValue = @(0.0);
@@ skipping 18 matching lines @@
   // set back to 1. There are a couple of ways to do this. The easiest is to
   // just have a dummy animation as part of the same animation group.
   CABasicAnimation* opacityAnimation =
       [CABasicAnimation animationWithKeyPath:@"opacity"];
   opacityAnimation.fromValue = @(1.0);
   opacityAnimation.toValue = @(1.0);
 
   // The root layer's size should start scaled down to the initial size of
   // |primaryWindow_|. The animation increases the size until the root layer
   // fills the screen.
-  NSRect initialFrame = primaryWindowInitialFrame_;
-  NSRect endFrame = primaryWindowFinalFrame_;
+  NSRect initialFrame = initialFrame_;
+  NSRect endFrame = finalFrame_;
   CGFloat xScale = NSWidth(initialFrame) / NSWidth(endFrame);
   CGFloat yScale = NSHeight(initialFrame) / NSHeight(endFrame);
   CATransform3D initial = CATransform3DMakeScale(xScale, yScale, 1);
   CABasicAnimation* transformAnimation =
       [CABasicAnimation animationWithKeyPath:@"transform"];
   transformAnimation.fromValue = [NSValue valueWithCATransform3D:initial];
 
-  CALayer* root = [self rootLayerOfWindow:primaryWindow_];
-
   // Calculate the initial position of the root layer. This calculation is
   // agnostic of the anchorPoint.
+  CALayer* root = [self rootLayerOfWindow:primaryWindow_];
   CGFloat layerStartPositionDeltaX = NSMidX(initialFrame) - NSMidX(endFrame);
   CGFloat layerStartPositionDeltaY = NSMidY(initialFrame) - NSMidY(endFrame);
   NSPoint layerStartPosition =
       NSMakePoint(root.position.x + layerStartPositionDeltaX,
                   root.position.y + layerStartPositionDeltaY);
 
   // Animate the primary window from its initial position.
   CABasicAnimation* positionAnimation =
       [CABasicAnimation animationWithKeyPath:@"position"];
   positionAnimation.fromValue = [NSValue valueWithPoint:layerStartPosition];
 
   CAAnimationGroup* group = [CAAnimationGroup animation];
   group.removedOnCompletion = NO;
   group.fillMode = kCAFillModeForwards;
   group.animations =
-      @[ transformAnimation, opacityAnimation, positionAnimation ];
+      @[ opacityAnimation, positionAnimation, transformAnimation ];
   group.timingFunction = [CAMediaTimingFunction
       functionWithName:TransformAnimationTimingFunction()];
   group.duration = duration;
   [group setValue:kPrimaryWindowAnimationID forKey:kAnimationIDKey];
   group.delegate = self;
 
   [root addAnimation:group forKey:kPrimaryWindowAnimationID];
 }
 
+- (void)changePrimaryWindowToFinalFrame {
+  changingPrimaryWindowSize_ = YES;
+  [primaryWindow_ setFrame:finalFrame_ display:NO];
+  changingPrimaryWindowSize_ = NO;
+}
+
 - (void)animationDidStop:(CAAnimation*)theAnimation finished:(BOOL)flag {
   NSString* animationID = [theAnimation valueForKey:kAnimationIDKey];
+
+  // Remove the snapshot window.
   if ([animationID isEqual:kSnapshotWindowAnimationID]) {
     [snapshotWindow_ orderOut:nil];
     snapshotWindow_.reset();
     snapshotLayer_.reset();
     return;
   }
 
   if ([animationID isEqual:kPrimaryWindowAnimationID]) {
-    [primaryWindow_ setOpaque:YES];
+    // If we're exiting full screen, we want to set the primary window
+    // size to the expected frame at the end. The window's frame will also
+    // need to be unlocked.
+    if (!isEnteringFullscreen_) {
+      lock_->setLock(NO);
+      [primaryWindow_
+          setStyleMask:[primaryWindow_ styleMask] & ~NSFullScreenWindowMask];
+      [self changePrimaryWindowToFinalFrame];
+    }
+
+    // Check if the final content view size is correct
+    NSSize expectedSize = finalFrame_.size;
+    NSView* content = [primaryWindow_ contentView];
+    DCHECK_EQ(NSHeight(content.frame), expectedSize.height);
+    DCHECK_EQ(NSWidth(content.frame), expectedSize.width);
+
+    // Restore the state of the primary window and make it visible again.
+    [primaryWindow_ setOpaque:primaryWindowInitialOpaque_];
     [primaryWindow_ setBackgroundColor:primaryWindowInitialBackgroundColor_];
+
     CALayer* root = [self rootLayerOfWindow:primaryWindow_];
+    [root removeAnimationForKey:kPrimaryWindowAnimationID];
     root.opacity = 1;
-    [root removeAnimationForKey:kPrimaryWindowAnimationID];
   }
 }
 
 - (CALayer*)rootLayerOfWindow:(NSWindow*)window {
   return [[[window contentView] superview] layer];
 }
 
 @end