Hide the tab indicators and the shelf when in immersive + tab fullscreen

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"
+#include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_service.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
@@ skipping 285 matching lines @@
       // Disable immersive mode when leaving the fullscreen state.
       ui::WindowShowState show_state = static_cast<ui::WindowShowState>(
           window->GetProperty(kShowStateKey));
       if (controller_->IsEnabled() &&
           show_state != ui::SHOW_STATE_FULLSCREEN &&
           show_state != ui::SHOW_STATE_MINIMIZED) {
         controller_->browser_view_->FullScreenStateChanged();
       }
       return;
     }
-    using ash::internal::kImmersiveModeKey;
-    if (key == kImmersiveModeKey) {
-      // Another component has toggled immersive mode.
-      controller_->SetEnabled(window->GetProperty(kImmersiveModeKey));
-      return;
-    }
   }
 
  private:
   ImmersiveModeControllerAsh* controller_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ImmersiveModeControllerAsh::ImmersiveModeControllerAsh()
     : browser_view_(NULL),
+      observers_enabled_(false),
       enabled_(false),
       reveal_state_(CLOSED),
       revealed_lock_count_(0),
-      hide_tab_indicators_(false),
+      tab_indicator_visibility_(TAB_INDICATORS_HIDE),
       native_window_(NULL),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 ImmersiveModeControllerAsh::~ImmersiveModeControllerAsh() {
   // The browser view is being destroyed so there's no need to update its
   // layout or layers, even if the top views are revealed. But the window
   // observers still need to be removed.
   EnableWindowObservers(false);
 }
@@ skipping 18 matching lines @@
 void ImmersiveModeControllerAsh::MaybeRevealWithoutAnimation() {
   MaybeStartReveal(ANIMATE_NO);
 }
 
 void ImmersiveModeControllerAsh::Init(BrowserView* browser_view) {
   browser_view_ = browser_view;
   // Browser view is detached from its widget during destruction. Cache the
   // window pointer so |this| can stop observing during destruction.
   native_window_ = browser_view_->GetNativeWindow();
   DCHECK(native_window_);
-  EnableWindowObservers(true);
 
   // Optionally allow the tab indicators to be hidden.
-  hide_tab_indicators_ = CommandLine::ForCurrentProcess()->
-      HasSwitch(ash::switches::kAshImmersiveHideTabIndicators);
+  if (CommandLine::ForCurrentProcess()->
+          HasSwitch(ash::switches::kAshImmersiveHideTabIndicators)) {
+    tab_indicator_visibility_ = TAB_INDICATORS_FORCE_HIDE;
+  }
 
   anchored_widget_manager_.reset(new AnchoredWidgetManager(this));
 }
 
 void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
   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);
+
   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.)
     MaybeStartReveal(ANIMATE_NO);
 
     // Reset the mouse and the focus revealed locks so that they do not affect
@@ skipping 16 matching lines @@
     // 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);
   }
   // Don't need explicit layout because we're inside a fullscreen transition
   // and it blocks layout calls.
 
-  // This causes a no-op call to SetEnabled() since enabled_ is already set.
-  native_window_->SetProperty(ash::internal::kImmersiveModeKey, enabled_);
-  // Ash on Windows may not have a shell.
-  if (ash::Shell::HasInstance()) {
-    // Shelf auto-hides in immersive mode.
-    ash::Shell::GetInstance()->UpdateShelfVisibility();
-  }
+  UpdateUseMinimalChrome(LAYOUT_NO);
 }
 
 bool ImmersiveModeControllerAsh::IsEnabled() const {
   return enabled_;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTabIndicators() const {
-  return hide_tab_indicators_;
+  return tab_indicator_visibility_ != TAB_INDICATORS_SHOW;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTopViews() const {
   return enabled_ && reveal_state_ == CLOSED;
 }
 
 bool ImmersiveModeControllerAsh::IsRevealed() const {
   return enabled_ && reveal_state_ != CLOSED;
 }
 
@@ skipping 21 matching lines @@
   anchored_widget_manager_->RemoveAnchoredWidget(widget);
 }
 
 void ImmersiveModeControllerAsh::OnTopContainerBoundsChanged() {
   anchored_widget_manager_->MaybeRepositionAnchoredWidgets();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Observers:
 
+void ImmersiveModeControllerAsh::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
+  if (enabled_)
+    UpdateUseMinimalChrome(LAYOUT_YES);
+}
+
 void ImmersiveModeControllerAsh::OnMouseEvent(ui::MouseEvent* event) {
   if (!enabled_)
     return;
 
   if (event->flags() & ui::EF_IS_SYNTHESIZED)
     return;
 
   // Handle ET_MOUSE_PRESSED and ET_MOUSE_RELEASED so that we get the updated
   // mouse position ASAP once a nested message loop finishes running.
   if (event->type() != ui::ET_MOUSE_MOVED &&
@@ skipping 63 matching lines @@
 void ImmersiveModeControllerAsh::OnImplicitAnimationsCompleted() {
   if (reveal_state_ == SLIDING_OPEN)
     OnSlideOpenAnimationCompleted();
   else if (reveal_state_ == SLIDING_CLOSED)
     OnSlideClosedAnimationCompleted();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Testing interface:
 
-void ImmersiveModeControllerAsh::SetHideTabIndicatorsForTest(bool hide) {
-  hide_tab_indicators_ = hide;
+void ImmersiveModeControllerAsh::SetForceHideTabIndicatorsForTest(bool force) {
+  if (force)
+    tab_indicator_visibility_ = TAB_INDICATORS_FORCE_HIDE;
+  else if (tab_indicator_visibility_ == TAB_INDICATORS_FORCE_HIDE)
+    tab_indicator_visibility_ = TAB_INDICATORS_HIDE;
+  UpdateUseMinimalChrome(LAYOUT_YES);
 }
 
 void ImmersiveModeControllerAsh::StartRevealForTest(bool hovered) {
   MaybeStartReveal(ANIMATE_NO);
   MoveMouse(browser_view_->top_container(), hovered);
   UpdateMouseRevealedLock(false);
 }
 
 void ImmersiveModeControllerAsh::SetMouseHoveredForTest(bool hovered) {
   MoveMouse(browser_view_->top_container(), hovered);
   UpdateMouseRevealedLock(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private:
 
 void ImmersiveModeControllerAsh::EnableWindowObservers(bool enable) {
+  if (observers_enabled_ == enable)
+    return;
+  observers_enabled_ = enable;
+
   if (!native_window_) {
-    DCHECK(!enable) << "ImmersiveModeControllerAsh not initialized";
+    NOTREACHED() << "ImmersiveModeControllerAsh not initialized";
     return;
   }
 
   views::Widget* widget =
       views::Widget::GetWidgetForNativeWindow(native_window_);
   views::FocusManager* focus_manager = widget->GetFocusManager();
   if (enable) {
     widget->AddObserver(this);
     focus_manager->AddFocusChangeListener(this);
   } else {
     widget->RemoveObserver(this);
     focus_manager->RemoveFocusChangeListener(this);
   }
 
   if (enable)
     native_window_->AddPreTargetHandler(this);
   else
     native_window_->RemovePreTargetHandler(this);
 
   // The window observer adds and removes itself from the native window.
   window_observer_.reset(enable ? new WindowObserver(this) : NULL);
 
+  if (enable) {
+    registrar_.Add(
+        this,
+        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+        content::Source<FullscreenController>(
+            browser_view_->browser()->fullscreen_controller()));
+  } else {
+    registrar_.Remove(
+        this,
+        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+        content::Source<FullscreenController>(
+            browser_view_->browser()->fullscreen_controller()));
+  }
+
   if (!enable)
     StopObservingImplicitAnimations();
 }
 
 void ImmersiveModeControllerAsh::UpdateMouseRevealedLock(bool maybe_drag) {
   if (!enabled_)
     return;
 
   // Hover cannot initiate a reveal when the top-of-window views are sliding
   // closed or are closed. (With the exception of hovering at y = 0 which is
@@ skipping 56 matching lines @@
   }
 
   if (hold_lock) {
     if (!focus_revealed_lock_.get())
       focus_revealed_lock_.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
   } else {
     focus_revealed_lock_.reset();
   }
 }
 
+void ImmersiveModeControllerAsh::UpdateUseMinimalChrome(Layout layout) {
+  bool in_tab_fullscreen = browser_view_->browser()->fullscreen_controller()->
+      IsFullscreenForTabOrPending();
+  bool use_minimal_chrome = !in_tab_fullscreen && enabled_;
+  native_window_->SetProperty(ash::internal::kFullscreenUsesMinimalChromeKey,
+                              use_minimal_chrome);
+
+  TabIndicatorVisibility previous_tab_indicator_visibility =
+      tab_indicator_visibility_;
+  if (tab_indicator_visibility_ != TAB_INDICATORS_FORCE_HIDE) {
+    tab_indicator_visibility_ = use_minimal_chrome ?
+        TAB_INDICATORS_SHOW : TAB_INDICATORS_HIDE;
+  }
+
+  // Ash on Windows may not have a shell.
+  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);
+  }
+}
+
 int ImmersiveModeControllerAsh::GetAnimationDuration(Animate animate) const {
   switch (animate) {
     case ANIMATE_NO:
       return 0;
     case ANIMATE_SLOW:
       return kRevealSlowAnimationDurationMs;
     case ANIMATE_FAST:
       return kRevealFastAnimationDurationMs;
   }
   NOTREACHED();
@@ skipping 156 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);
 }