[Not for review] Demo issue for discussion on https://codereview.chromium.org/2296903002/.

chrome/browser/ui/cocoa/fullscreen_toolbar_controller.mm

 // Copyright (c) 2012 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/fullscreen_toolbar_controller.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #import "base/mac/mac_util.h"
@@ skipping 177 matching lines @@
 @implementation FullscreenToolbarController
 
 @synthesize slidingStyle = slidingStyle_;
 
 - (id)initWithBrowserController:(BrowserWindowController*)controller
                           style:(fullscreen_mac::SlidingStyle)style {
   if ((self = [super init])) {
     browserController_ = controller;
     systemFullscreenMode_ = base::mac::kFullScreenModeNormal;
     slidingStyle_ = style;
-    hiddenToolbarState_ = fullscreen_mac::TOOLBAR_HIDDEN;
   }
 
   // Install the Carbon event handler for the menubar show, hide and
   // undocumented reveal event.
   EventTypeSpec eventSpecs[3];
 
   eventSpecs[0].eventClass = kEventClassMenu;
   eventSpecs[0].eventKind = kMenuBarRevealEventKind;
 
   eventSpecs[1].eventClass = kEventClassMenu;
@@ skipping 82 matching lines @@
     return;
 
   if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_HIDDEN)
     return;
 
   if ([self isToolbarFocused])
     return;
 
   [self cancelHideTimer];
   [self animateToolbarVisibility:NO];
-  shouldShowToolbarWithoutMenu_ = NO;
+
+  // The animation will tell us the appropriate progress.
+  // shouldShowToolbarWithoutMenu_ = NO;
 }
 
 - (void)cancelAnimationAndTimer {
   [self cancelHideTimer];
   [currentAnimation_ stopAnimation];
   currentAnimation_.reset();
 }
 
 - (void)revealToolbarForTabStripChanges {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableFullscreenToolbarReveal)) {
     return;
   }
 
   if (self.slidingStyle != fullscreen_mac::OMNIBOX_TABS_HIDDEN)
     return;
 
   // Reveal the toolbar for tabstrip changes if the toolbar is hidden.
-  if (hiddenToolbarState_ == fullscreen_mac::TOOLBAR_HIDDEN) {
+  if ([self toolbarFraction] == 0.0) {
     isRevealingToolbarForTabStripChanges_ = YES;
     [self showToolbarIfPossibleWithAnimation:YES];
   }
 }
 
 - (void)setSystemFullscreenModeTo:(base::mac::FullScreenMode)mode {
   if (mode == systemFullscreenMode_)
     return;
   if (systemFullscreenMode_ == base::mac::kFullScreenModeNormal)
     base::mac::RequestFullScreen(mode);
@@ skipping 53 matching lines @@
 - (CGFloat)toolbarFraction {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return kHideFraction;
 
   switch (slidingStyle_) {
     case fullscreen_mac::OMNIBOX_TABS_PRESENT:
       return kShowFraction;
     case fullscreen_mac::OMNIBOX_TABS_NONE:
       return kHideFraction;
     case fullscreen_mac::OMNIBOX_TABS_HIDDEN:
-      if (hiddenToolbarState_ == fullscreen_mac::TOOLBAR_SHOWN)
+      // If the menubar is showing, we always want to show the toolbar.
+      if (menubarState_ == fullscreen_mac::MENUBAR_SHOWN) {
         return kShowFraction;
+      }
 
-      if (hiddenToolbarState_ == fullscreen_mac::TOOLBAR_HIDDEN)
-        return kHideFraction;
+      // If the menubar is animating in, and the toolbar was not already
+      // showing, then it should animate in at the same rate.
+      if (menubarState_ == fullscreen_mac::MENUBAR_TRANSITIONING && menubarAnimatingIn_ &&
+          !wasToolbarShowingWhenMenubarStartedAnimatingIn_) {
+        return menubarFraction_;
+      }
 
+      // If the menubar is animating in, and the toolbar is already showing,
+      // then continue to show it.
+      if (menubarState_ == fullscreen_mac::MENUBAR_TRANSITIONING &&
+          menubarAnimatingIn_) {
+        return kShowFraction;
+      }
+
+      // If the menubar is animating out, we ignore!.
+      if (menubarState_ == fullscreen_mac::MENUBAR_TRANSITIONING &&
+          !menubarAnimatingIn_) {
+      }
+
+      // At this point, menubar is not showing. Is there a custom animation?
       if (currentAnimation_.get())
         return [currentAnimation_ toolbarFraction];
 
-      return shouldShowToolbarWithoutMenu_ ? kShowFraction : menubarFraction_;
+      // If mouse is in tracking rect, show toolbar:
+
+      // If there's a hide timer, show toolbar:
+
+      // Logic for show & hide tab strip on tab change...haven't thought through
+      // all the edge cases.
+
+      // Default: hide toolbar.
   }
 }
 
 - (BOOL)isFullscreenTransitionInProgress {
   return [browserController_ isFullscreenTransitionInProgress];
 }
 
 - (BOOL)isInFullscreen {
   return inFullscreenMode_;
 }
 
 - (BOOL)isMouseOnScreen {
   return NSMouseInRect([NSEvent mouseLocation],
                        [[browserController_ window] screen].frame, false);
 }
 
 - (void)setTrackingAreaFromOverlayFrame:(NSRect)frame {
   NSRect contentBounds = [contentView_ bounds];
   CGFloat yOffset =
       kFloatingBarVerticalOffset - kTrackingAreaAdditionalThreshold;
 
   trackingAreaFrame_ = frame;
   trackingAreaFrame_.origin.y += yOffset;
   trackingAreaFrame_.size.height =
       NSMaxY(contentBounds) - trackingAreaFrame_.origin.y;
 }
 
 - (void)animationDidStop:(NSAnimation*)animation {
   CGFloat toolbarFraction = [self toolbarFraction];
-  if (IsCGFloatEqual(toolbarFraction, 1.0))
-    hiddenToolbarState_ = fullscreen_mac::TOOLBAR_SHOWN;
-  else if (IsCGFloatEqual(toolbarFraction, 0.0))
-    hiddenToolbarState_ = fullscreen_mac::TOOLBAR_HIDDEN;
-  else
-    hiddenToolbarState_ = fullscreen_mac::TOOLBAR_TRANSITIONING;
 
   if (isRevealingToolbarForTabStripChanges_) {
-    if (hiddenToolbarState_ != fullscreen_mac::TOOLBAR_HIDDEN) {
+    if (IsCGFloatEqual(toolbarFraction, 0.0)) {
       // Set the timer to hide the toolbar.
       [hideTimer_ invalidate];
       hideTimer_.reset(
           [[NSTimer scheduledTimerWithTimeInterval:kTabStripChangesDelay
                                             target:self
                                           selector:@selector(hideTimerFire:)
                                           userInfo:nil
                                            repeats:NO] retain]);
     } else {
       isRevealingToolbarForTabStripChanges_ = NO;
     }
   }
 
   // Reset the |currentAnimation_| pointer now that the animation is over.
   currentAnimation_.reset();
 }
 
 - (void)animationDidEnd:(NSAnimation*)animation {
   [self animationDidStop:animation];
   [self setupTrackingArea];
 }
 
 - (void)setMenuBarRevealProgress:(CGFloat)progress {
+  // TODO: What happens if a mouse quickly bounces between two screens? What we
+  // really want to know is whether the callback is for the screen that the
+  // browser window is on. I'm not sure what the "progress > menubarFraction_"
+  // check is for but it seems wrong?
   // If the menubarFraction increases, check if we are in the right screen
   // so that the toolbar is not revealed on the wrong screen.
   if (![self isMouseOnScreen] && progress > menubarFraction_)
     return;
 
-  BOOL isMenuBarDisappearing = progress < menubarFraction_;
+  if (IsCGFloatEqual(menubarFraction_, kShowFraction)) {
+    // NSMenubar fully showing.
+    menubarState_ = fullscreen_mac::MENUBAR_SHOWN;
+  } else if (IsCGFloatEqual(menubarFraction_, kShowFraction)) {
+    // NSMenubar fully hidden.
+    menubarState_ = fullscreen_mac::MENUBAR_HIDDEN;
+  } else {
+    menubarState_ = fullscreen_mac::MENUBAR_TRANSITIONING;
+    menubarAnimatingIn_ = progress > menubarFraction_;
+    if (IsCGFloatEqual(menubarFraction_, kHideFraction) && menubarAnimatingIn_) {
+      // TODO: What if toolbar was animating when menubar starts animating in?
+      // We need to decide what behavior we want. I think we want to override
+      // the existing animation, so this should be toolbarFraction > 0.
+      wasToolbarShowingWhenMenubarStartedAnimatingIn_ = IsCGFloatEqual([self toolbarFraction], kShowFraction);
+    }
+  }
   menubarFraction_ = progress;
 
-  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_HIDDEN) {
-    shouldShowToolbarWithoutMenu_ =
-        shouldShowToolbarWithoutMenu_ ||
-        (isMenuBarDisappearing && [self isToolbarFocused]);
-
-    if (IsCGFloatEqual(menubarFraction_, kShowFraction)) {
-      [self setupTrackingArea];
-      hiddenToolbarState_ = fullscreen_mac::TOOLBAR_SHOWN;
-    }
-
-    // If |shouldShowToolbarWithoutMenu_| is true, then |hiddenToolbarState_|
-    // should remain fullscreen_mac::TOOLBAR_SHOWN.
-    if (!shouldShowToolbarWithoutMenu_) {
-      hiddenToolbarState_ = IsCGFloatEqual(menubarFraction_, kHideFraction)
-                                ? fullscreen_mac::TOOLBAR_HIDDEN
-                                : fullscreen_mac::TOOLBAR_TRANSITIONING;
-    }
+  if (self.slidingStyle == fullscreen_mac::OMNIBOX_TABS_HIDDEN &&
+      menubarState_ == fullscreen_mac::MENUBAR_SHOWN) {
+    [self setupTrackingArea];
   }
 
   // If an animation is not running, then -layoutSubviews will not be called
   // for each tick of the menu bar reveal. Do that manually.
   // TODO(erikchen): The animation is janky. layoutSubviews need a refactor so
   // that it calls setFrameOffset: instead of setFrame: if the frame's size has
   // not changed.
   if (!currentAnimation_.get())
     [browserController_ layoutSubviews];
 }
@@ skipping 102 matching lines @@
             controller:self]);
   DCHECK(currentAnimation_);
   [currentAnimation_ setAnimationBlockingMode:NSAnimationNonblocking];
   [currentAnimation_ setDelegate:self];
 
   // If there is an existing tracking area, remove it. We do not track mouse
   // movements during animations (see class comment in the header file).
   [self removeTrackingAreaIfNecessary];
 
   [currentAnimation_ startAnimation];
-  hiddenToolbarState_ = fullscreen_mac::TOOLBAR_TRANSITIONING;
 }
 
 - (void)cancelHideTimer {
   [hideTimer_ invalidate];
   hideTimer_.reset();
 }
 
 - (void)hideTimerFire:(NSTimer*)timer {
   DCHECK_EQ(hideTimer_, timer);  // This better be our hide timer.
   [hideTimer_ invalidate];       // Make sure it doesn't repeat.
@@ skipping 14 matching lines @@
 
   // No more calls back up to the BWC.
   browserController_ = nil;
 }
 
 - (BOOL)shouldShowMenubarInImmersiveFullscreen {
   return [self doesScreenHaveMenuBar] && [self toolbarFraction] > 0.99;
 }
 
 @end