Fix for Exit Fullscreen Animation

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_fullscreen_transition.h"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.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/tabs/tab_strip_background_view.h"
 
 namespace {
 
 NSString* const kPrimaryWindowAnimationID = @"PrimaryWindowAnimationID";
 NSString* const kSnapshotWindowAnimationID = @"SnapshotWindowAnimationID";
 NSString* const kAnimationIDKey = @"AnimationIDKey";
 
+// The fraction of the duration from AppKit's startCustomAnimation methods
+// that we want our animation to run in.
+CGFloat const kAnimationDurationFrame = 0.5;

[erikchen, 2015/11/09 18:29:21]

maybe kAnimationDurationFraction?

[spqchan, 2015/11/09 22:27:19]

Done.

+
 // 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:
   explicit FrameAndStyleLock(FramedBrowserWindow* window) : window_(window) {}
 
   ~FrameAndStyleLock() { set_lock(NO); }
 
-  void set_lock(bool lock) { [window_ setFrameAndStyleMaskLock:lock]; }
+  void set_lock(bool lock) { [window_ setStyleMaskLock:lock]; }
 
  private:
   FramedBrowserWindow* window_;  // weak
 
   DISALLOW_COPY_AND_ASSIGN(FrameAndStyleLock);
 };
 
 }  // namespace
 
+// This view draws a dummy toolbar over the resized content view during
+// the exit fullscreen animation. It is removed at the end of the animation.
+@interface FullscreenTabStripBackgroundView : NSView {
+  base::scoped_nsobject<NSColor> windowBackgroundColor_;
+}
+
+- (instancetype)initWithFrame:(NSRect)frame background:(NSColor*)color;
+
+@end
+
+@implementation FullscreenTabStripBackgroundView
+
+- (instancetype)initWithFrame:(NSRect)frame background:(NSColor*)color {
+  if ((self = [super initWithFrame:frame])) {
+    windowBackgroundColor_.reset([color copy]);
+  }
+  return self;
+}
+
+// Override this method so that we can paint the toolbar in this view.
+// This method first fill itself with the toolbar's background. After that,
+// it will paint the window's theme if applicable.
+- (void)drawRect:(NSRect)frame {
+  [windowBackgroundColor_ set];
+  NSRectFillUsingOperation(frame, NSCompositeDestinationOver);
+
+  [FramedBrowserWindow drawWindowThemeInDirtyRect:frame
+                                          forView:self
+                                           bounds:[self bounds]
+                             forceBlackBackground:NO];
+}
+
+@end
+
 @interface BrowserWindowFullscreenTransition () {
   // Flag to keep track of whether we are entering or exiting fullscreen.
   BOOL isEnteringFullscreen_;
 
   // The window which is undergoing the fullscreen transition.
   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 tabstrip background view in the window. During the exit fullscreen
+  // animation, this view be hidden while a dummy tabstrip background will be
+  // drawn over the content view.
+  base::scoped_nsobject<NSView> tabStripBackgroundView_;
+
   // The background color of |primaryWindow_| before the transition began.
   base::scoped_nsobject<NSColor> primaryWindowInitialBackgroundColor_;
 
   // Whether |primaryWindow_| was opaque before the transition began.
   BOOL primaryWindowInitialOpaque_;
 
+  // The initial anchor point of the root layer.
+  CGPoint initialRootAnchorPoint_;
+
+  // The initial origin of the content view.
+  NSPoint initialContentViewOrigin_;
+
   // 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_;
 
   // The frame that |primaryWindow_| is expected to have after the transition
   // is finished.
   NSRect finalFrame_;
 
+  // This view draws the tabstrip background during the exit animation.
+  base::scoped_nsobject<FullscreenTabStripBackgroundView>
+      fullscreenTabStripBackgroundView_;
+
   // 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;
 
@@ skipping 45 matching lines @@
     primaryWindow_.reset([window retain]);
 
     isEnteringFullscreen_ = YES;
     initialFrame_ = [primaryWindow_ frame];
     finalFrame_ = [[primaryWindow_ screen] frame];
   }
   return self;
 }
 
 - (instancetype)initExitWithWindow:(FramedBrowserWindow*)window
-                             frame:(NSRect)frame {
+                             frame:(NSRect)frame
+            tabStripBackgroundView:(NSView*)view {
   DCHECK(window);
   DCHECK([self rootLayerOfWindow:window]);
   if ((self = [super init])) {
     primaryWindow_.reset([window retain]);
-
+    tabStripBackgroundView_.reset([view retain]);
     isEnteringFullscreen_ = NO;
     finalFrame_ = frame;
     initialFrame_ = [[primaryWindow_ screen] frame];
 
     lock_.reset(new FrameAndStyleLock(window));
   }
   return self;
 }
 
 - (NSArray*)customWindowsForFullScreenTransition {
   [self takeSnapshot];
   [self makeAndPrepareSnapshotWindow];
   return @[ primaryWindow_.get(), snapshotWindow_.get() ];
 }
 
 - (void)startCustomFullScreenAnimationWithDuration:(NSTimeInterval)duration {
+  CGFloat animationDuration = duration * kAnimationDurationFrame;
   [self preparePrimaryWindowForAnimation];
-  [self animatePrimaryWindowWithDuration:duration];
-  [self animateSnapshotWindowWithDuration:duration];
+  [self animatePrimaryWindowWithDuration:animationDuration];
+  [self animateSnapshotWindowWithDuration:animationDuration];
 }
 
 - (BOOL)shouldWindowBeUnconstrained {
   return changingPrimaryWindowSize_;
 }
 
 - (NSSize)desiredWindowLayoutSize {
   return isEnteringFullscreen_ ? [primaryWindow_ frame].size
                                : [[primaryWindow_ contentView] bounds].size;
 }
@@ skipping 26 matching lines @@
   [snapshotWindow_ setBackgroundColor:[NSColor clearColor]];
   [snapshotWindow_ setAnimationBehavior:NSWindowAnimationBehaviorNone];
 
   [[[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];
+
+  if (isEnteringFullscreen_)
+    [snapshotWindow_ orderFront:nil];
 }
 
 - (void)preparePrimaryWindowForAnimation {
   // Save the initial state of the primary window.
   primaryWindowInitialBackgroundColor_.reset(
       [[primaryWindow_ backgroundColor] copy]);
   primaryWindowInitialOpaque_ = [primaryWindow_ isOpaque];
 
   // Make |primaryWindow_| invisible. This must happen before the window is
   // resized, since resizing the window will call drawRect: and cause content
   // to flash over the entire screen.
   [primaryWindow_ setOpaque:NO];
-  CALayer* root = [self rootLayerOfWindow:primaryWindow_];
-  root.opacity = 0;
 
   if (isEnteringFullscreen_) {
     // 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.
+
+    CALayer* root = [self rootLayerOfWindow:primaryWindow_];
+    root.opacity = 0;
+
     [primaryWindow_
         setStyleMask:[primaryWindow_ styleMask] | NSFullScreenWindowMask];
     [self changePrimaryWindowToFinalFrame];
   } else {
-    // Set the size of the root layer to the size of the final frame. The root
-    // layer is placed at position (0, 0) because the animation will take care
-    // of the layer's start and end position.
-    root.frame =
-        NSMakeRect(0, 0, finalFrame_.size.width, finalFrame_.size.height);
+    [snapshotWindow_ orderFront:nil];

[erikchen, 2015/11/09 18:29:21]

what's with the different in timing? Can you add comments indicating why this
happens at a different time from line 270?

[spqchan, 2015/11/09 22:27:19]

Done.

+
+    NSView* contentView = [primaryWindow_ contentView];
+    NSView* rootView = [contentView superview];
+
+    // Since only the content view is resized, the window's background
+    // must transparent. This is a hack that forces the layer to remove

[erikchen, 2015/11/09 18:29:21]

s/must/must be/

[spqchan, 2015/11/09 22:27:19]

Done.

+    // the textured background and replace it with clearColor.
+    [rootView setWantsLayer:NO];

[erikchen, 2015/11/09 18:29:21]

Why does this hack work? Shouldn't we be able to make the window's background be
clearColor without this hack?

[spqchan, 2015/11/09 22:27:19]

Having NSTexturedBackgroundWindowMask prevents the window's background from
being changed.
Simply removing the mask and setting the clearColor does not work, there are
certain parts of the CALayer that's not being updated causing it to think it
still have a textured background, thus ignoring the window's new background
color. This hack forces the layer to be updated with the new background color.

[erikchen, 2015/11/10 02:15:43]

Why can't you use -setNeedsDisplay or something similar directly on the layer? 

[spqchan, 2015/11/10 18:45:31]

I tried to use setNeedsDisplay, updateLayer and various undocumented layer
"redrawing/updating" methods I found via Hopper.
I strongly suspect that the issue isn't that the layer isn't updating its
appearance, but rather some undocumented variables associated with the layer are
not being set.

+    [primaryWindow_ setBackgroundColor:[NSColor clearColor]];
+    [primaryWindow_ setStyleMask:[primaryWindow_ styleMask] &
+                                 ~NSTexturedBackgroundWindowMask];
+    [rootView setWantsLayer:YES];
+
+    CALayer* root = [self rootLayerOfWindow:primaryWindow_];
+    root.opacity = 0;
 
     // Right before the animation begins, change the contentView size to the
     // expected size at the end of the animation. Afterwards, lock the
     // |primaryWindow_| so that AppKit will not be able to make unwanted
     // changes to it during the animation.
-    [primaryWindow_ forceContentViewSize:finalFrame_.size];
+    initialContentViewOrigin_ = [[primaryWindow_ contentView] frame].origin;
+    initialRootAnchorPoint_ = root.anchorPoint;
+
+    NSPoint contentViewOrigin =
+        [self pointRelativeToCurrentScreen:finalFrame_.origin];
+    NSRect relativeContentFinalFrame =
+        NSMakeRect(contentViewOrigin.x, contentViewOrigin.y,
+                   finalFrame_.size.width, finalFrame_.size.height);
+    [primaryWindow_ forceContentViewFrame:relativeContentFinalFrame];
+    [contentView setAutoresizesSubviews:NO];

[erikchen, 2015/11/09 18:29:21]

Why? If we're preventing the frame from changing, this should be unnecessary,
right?

[spqchan, 2015/11/09 22:27:19]

We don't actually prevent the frame from changing. We prevent the size of the
content view from becoming smaller than the window's frame. 

In OSX 10.11, when the NSFullScreenWindowMask is added or removed, window's
frame changes slightly which causes a janky movement at the beginning/end of the
animation. Anyway I added a comment for this.

+
+    fullscreenTabStripBackgroundView_.reset(
+        [[FullscreenTabStripBackgroundView alloc]
+            initWithFrame:finalFrame_
+               background:primaryWindowInitialBackgroundColor_]);
+    [fullscreenTabStripBackgroundView_ setFrameOrigin:NSZeroPoint];
+    [contentView addSubview:fullscreenTabStripBackgroundView_.get()
+                 positioned:NSWindowBelow
+                 relativeTo:nil];
+
+    [tabStripBackgroundView_ setHidden:YES];
+
+    // Set anchor point to be the center of the content view
+    CGFloat anchorPointX =
+        NSMidX(relativeContentFinalFrame) / NSWidth(initialFrame_);
+    CGFloat anchorPointY =
+        NSMidY(relativeContentFinalFrame) / NSHeight(initialFrame_);
+    root.anchorPoint = CGPointMake(anchorPointX, anchorPointY);
+
     lock_->set_lock(YES);
   }
 }
 
 - (void)animateSnapshotWindowWithDuration:(CGFloat)duration {
-  [snapshotWindow_ orderFront:nil];
-
   // Calculate the frame so that it's relative to the screen.
   NSRect finalFrameRelativeToScreen =
       [snapshotWindow_ convertRectFromScreen:finalFrame_];
 
   // Move the snapshot layer until it's bottom-left corner is at the the
   // bottom-left corner of the expected frame.
   CABasicAnimation* positionAnimation =
       [CABasicAnimation animationWithKeyPath:@"position"];
   positionAnimation.toValue =
       [NSValue valueWithPoint:finalFrameRelativeToScreen.origin];
@@ skipping 54 matching lines @@
   // Animate the primary window from its initial position, the center of the
   // initial window.
   CABasicAnimation* positionAnimation =
       [CABasicAnimation animationWithKeyPath:@"position"];
   NSPoint centerOfInitialFrame =
       NSMakePoint(NSMidX(initialFrame), NSMidY(initialFrame));
   NSPoint startingLayerPoint =
       [self pointRelativeToCurrentScreen:centerOfInitialFrame];
   positionAnimation.fromValue = [NSValue valueWithPoint:startingLayerPoint];
 
-  // Since the root layer's frame is different from the window, AppKit might
-  // animate it to a different position if we have multiple windows in
-  // fullscreen. This ensures that the animation moves to the correct position.
-  CGFloat anchorPointX = NSWidth(endFrame) / 2;
-  CGFloat anchorPointY = NSHeight(endFrame) / 2;
-  NSPoint endLayerPoint = [self pointRelativeToCurrentScreen:endFrame.origin];
-  positionAnimation.toValue =
-      [NSValue valueWithPoint:NSMakePoint(endLayerPoint.x + anchorPointX,
-                                          endLayerPoint.y + anchorPointY)];
+  NSPoint endingLayerPoint =
+      [self pointRelativeToCurrentScreen:NSMakePoint(NSMidX(endFrame),
+                                                     NSMidY(endFrame))];
+  positionAnimation.toValue = [NSValue valueWithPoint:endingLayerPoint];
 
   CAAnimationGroup* group = [CAAnimationGroup animation];
   group.removedOnCompletion = NO;
   group.fillMode = kCAFillModeForwards;
   group.animations =
       @[ opacityAnimation, positionAnimation, transformAnimation ];
   group.timingFunction = [CAMediaTimingFunction
       functionWithName:TransformAnimationTimingFunction()];
   group.duration = duration;
   [group setValue:kPrimaryWindowAnimationID forKey:kAnimationIDKey];
@@ skipping 19 matching lines @@
     snapshotLayer_.reset();
     return;
   }
 
   if ([animationID isEqual:kPrimaryWindowAnimationID]) {
     // If we're exiting full screen, we want to set the |primaryWindow_|'s
     // frame to the expected frame at the end of the animation. The window's
     // lock must also be released.
     if (!isEnteringFullscreen_) {
       lock_->set_lock(NO);
+
+      CALayer* root = [self rootLayerOfWindow:primaryWindow_];
+      root.anchorPoint = initialRootAnchorPoint_;
+
       [primaryWindow_
           setStyleMask:[primaryWindow_ styleMask] & ~NSFullScreenWindowMask];

[erikchen, 2015/11/09 18:29:21]

does this need to be 2 separate calls to setStyleMask?

[spqchan, 2015/11/09 22:27:19]

I separated them so that it looks cleaner. I'll go ahead and combine them
anyway.

+      [primaryWindow_ setStyleMask:[primaryWindow_ styleMask] |
+                                   NSTexturedBackgroundWindowMask];
+
+      NSView* content = [primaryWindow_ contentView];
+      [content setFrameOrigin:initialContentViewOrigin_];
       [self changePrimaryWindowToFinalFrame];
+      [[primaryWindow_ contentView] setAutoresizesSubviews:YES];
+
+      [tabStripBackgroundView_ setHidden:NO];
+      [fullscreenTabStripBackgroundView_ removeFromSuperview];
     }
 
     // Checks if the contentView 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;
   }
 }
 
 - (CALayer*)rootLayerOfWindow:(NSWindow*)window {
   return [[[window contentView] superview] layer];
 }
 
 - (NSPoint)pointRelativeToCurrentScreen:(NSPoint)point {
   NSRect screenFrame = [[primaryWindow_ screen] frame];
   return NSMakePoint(point.x - screenFrame.origin.x,
                      point.y - screenFrame.origin.y);
 }
 
 @end