Fix the size of the tabs when exiting immersive fullscreen with the tab indicators hidden

chrome/browser/ui/views/frame/immersive_mode_controller_ash.cc

 // Copyright 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.
 
 #include "chrome/browser/ui/views/frame/immersive_mode_controller_ash.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/wm/window_properties.h"
 #include "base/command_line.h"
@@ skipping 220 matching lines @@
 
 void ImmersiveModeControllerAsh::AnchoredWidgetManager::UpdateRevealedLock() {
   if (visible_.empty()) {
     revealed_lock_.reset();
   } else if (controller_->IsRevealed()) {
     // It is hard to determine the required initial transforms and the required
     // durations of the animations of |visible_| such that they appear to be
     // anchored to the top-of-window views while the top-of-window views are
     // animating. Skip to the end of the reveal animation instead.
     // We do not query the controller's reveal state because we may be called
-    // as a result of LayoutBrowserView() in MaybeStartReveal() when
+    // as a result of LayoutBrowserRootView() in MaybeStartReveal() when
     // |reveal_state_| is SLIDING_OPEN but no animation is running yet.
     ui::Layer* top_container_layer =
         controller_->browser_view_->top_container()->layer();
     if (top_container_layer &&
         top_container_layer->GetAnimator()->is_animating()) {
       controller_->MaybeRevealWithoutAnimation();
     }
 
     if (!revealed_lock_.get()) {
       revealed_lock_.reset(controller_->GetRevealedLock(
@@ skipping 160 matching lines @@
   DCHECK(browser_view_) << "Must initialize before enabling";
   if (enabled_ == enabled)
     return;
   enabled_ = enabled;
 
   // Delay the initialization of the window observers till the first call to
   // SetEnabled(true) because FullscreenController is not yet initialized when
   // Init() is called.
   EnableWindowObservers(true);
 
+  UpdateUseMinimalChrome(LAYOUT_NO);
+
   if (enabled_) {
     // Animate enabling immersive mode by sliding out the top-of-window views.
     // No animation occurs if a lock is holding the top-of-window views open.
 
     // Do a reveal to set the initial state for the animation. (And any
     // required state in case the animation cannot run because of a lock holding
-    // the top-of-window views open.)
+    // the top-of-window views open.) This call has the side effect of relaying
+    // out |browser_view_|'s root view.
     MaybeStartReveal(ANIMATE_NO);
 
     // Reset the mouse and the focus revealed locks so that they do not affect
     // whether the top-of-window views are hidden.
     mouse_revealed_lock_.reset();
     focus_revealed_lock_.reset();
 
     // Try doing the animation.
     MaybeEndReveal(ANIMATE_SLOW);
 
     if (reveal_state_ == REVEALED) {
       // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
       UpdateMouseRevealedLock(true);
       UpdateFocusRevealedLock();
     }
     anchored_widget_manager_->OnImmersiveModeEnabled();
   } else {
     // Stop cursor-at-top tracking.
     top_timer_.Stop();
     // Snap immediately to the closed state.
     reveal_state_ = CLOSED;
     EnablePaintToLayer(false);
-    browser_view_->GetWidget()->non_client_view()->frame_view()->
-        ResetWindowControls();
     browser_view_->tabstrip()->SetImmersiveStyle(false);
+
+    // Relayout the root view because disabling immersive fullscreen may have
+    // changed the result of NonClientFrameView::GetBoundsForClientView().
+    LayoutBrowserRootView();
   }
-  // Don't need explicit layout because we're inside a fullscreen transition
-  // and it blocks layout calls.
-
-  UpdateUseMinimalChrome(LAYOUT_NO);
 }
 
 bool ImmersiveModeControllerAsh::IsEnabled() const {
   return enabled_;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTabIndicators() const {
   return tab_indicator_visibility_ != TAB_INDICATORS_SHOW;
 }
 
@@ skipping 287 matching lines @@
   if (ash::Shell::HasInstance()) {
     // When using minimal chrome, the shelf is auto-hidden. The auto-hidden
     // shelf displays a 3px 'light bar' when it is closed.
     ash::Shell::GetInstance()->UpdateShelfVisibility();
   }
 
   if (tab_indicator_visibility_ != previous_tab_indicator_visibility) {
     // If the top-of-window views are revealed or animating, the change will
     // take effect with the layout once the top-of-window views are closed.
     if (layout == LAYOUT_YES && reveal_state_ == CLOSED)
-      LayoutBrowserView(true);
+      LayoutBrowserRootView();
   }
 }
 
 int ImmersiveModeControllerAsh::GetAnimationDuration(Animate animate) const {
   switch (animate) {
     case ANIMATE_NO:
       return 0;
     case ANIMATE_SLOW:
       return kRevealSlowAnimationDurationMs;
     case ANIMATE_FAST:
@@ skipping 17 matching lines @@
   }
 
   RevealState previous_reveal_state = reveal_state_;
   reveal_state_ = SLIDING_OPEN;
   if (previous_reveal_state == CLOSED) {
     // Turn on layer painting so we can smoothly animate.
     EnablePaintToLayer(true);
 
     // Ensure window caption buttons are updated and the view bounds are
     // computed at normal (non-immersive-style) size.
-    LayoutBrowserView(false);
+    browser_view_->tabstrip()->SetImmersiveStyle(false);
+    LayoutBrowserRootView();
 
     // Do not do any more processing if LayoutBrowserView() changed
     // |reveal_state_|.
     if (reveal_state_ != SLIDING_OPEN)
       return;
 
     if (animate != ANIMATE_NO) {
       // Now that we have a layer, move it to the initial offscreen position.
       ui::Layer* layer = browser_view_->top_container()->layer();
       gfx::Transform transform;
@@ skipping 25 matching lines @@
   // BrowserView::PaintChildren() always draws it last when it is visible.
   BookmarkBarView* bookmark_bar = browser_view_->bookmark_bar();
   if (!bookmark_bar)
     return;
   if (enable && bookmark_bar->IsDetached())
     bookmark_bar->SetPaintToLayer(true);
   else
     bookmark_bar->SetPaintToLayer(false);
 }
 
-void ImmersiveModeControllerAsh::LayoutBrowserView(bool immersive_style) {
+void ImmersiveModeControllerAsh::LayoutBrowserRootView() {
   // Update the window caption buttons.
   browser_view_->GetWidget()->non_client_view()->frame_view()->
       ResetWindowControls();
-  browser_view_->tabstrip()->SetImmersiveStyle(immersive_style);
   browser_view_->frame()->GetRootView()->Layout();
 }
 
 void ImmersiveModeControllerAsh::OnSlideOpenAnimationCompleted() {
   DCHECK_EQ(SLIDING_OPEN, reveal_state_);
   reveal_state_ = REVEALED;
 
   // The user may not have moved the mouse since the reveal was initiated.
   // Update the revealed lock to reflect the mouse's current state.
   UpdateMouseRevealedLock(true);
@@ skipping 30 matching lines @@
     OnSlideClosedAnimationCompleted();
   }
 }
 
 void ImmersiveModeControllerAsh::OnSlideClosedAnimationCompleted() {
   DCHECK_EQ(SLIDING_CLOSED, reveal_state_);
   reveal_state_ = CLOSED;
   // Layers aren't needed after animation completes.
   EnablePaintToLayer(false);
   // Update tabstrip for closed state.
-  LayoutBrowserView(true);
+  browser_view_->tabstrip()->SetImmersiveStyle(true);
+  LayoutBrowserRootView();
 }
 
 void ImmersiveModeControllerAsh::DoAnimation(
     const gfx::Transform& target_transform,
     int duration_ms) {
   StopObservingImplicitAnimations();
   DoLayerAnimation(browser_view_->top_container()->layer(), target_transform,
       duration_ms, this);
 
   typedef std::set<views::Widget*> WidgetSet;
@@ skipping 20 matching lines @@
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
   settings.SetTweenType(ui::Tween::EASE_OUT);
   settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(duration_ms));
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   if (observer)
     settings.AddObserver(observer);
   layer->SetTransform(target_transform);
 }