[Refactor] Replace kFullscreenUsesMinimalChromeKey with WindowState::hide_shelf_when_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 <set>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
-#include "ash/wm/window_properties.h"
-#include "base/command_line.h"
+#include "ash/wm/window_state.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
 #include "chrome/browser/ui/immersive_fullscreen_configuration.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 236 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 ImmersiveModeControllerAsh::ImmersiveModeControllerAsh()
     : delegate_(NULL),
       widget_(NULL),
       top_container_(NULL),
       observers_enabled_(false),
       enabled_(false),
       reveal_state_(CLOSED),
       revealed_lock_count_(0),
-      tab_indicator_visibility_(TAB_INDICATORS_HIDE),
       mouse_x_when_hit_top_in_screen_(-1),
       gesture_begun_(false),
       native_window_(NULL),
       animation_(new gfx::SlideAnimation(this)),
       animations_disabled_for_test_(false),
       weak_ptr_factory_(this) {
 }
 
 ImmersiveModeControllerAsh::~ImmersiveModeControllerAsh() {
   // The browser view is being destroyed so there's no need to update its
@@ skipping 27 matching lines @@
 void ImmersiveModeControllerAsh::Init(
     Delegate* delegate,
     views::Widget* widget,
     views::View* top_container) {
   delegate_ = delegate;
   widget_ = widget;
   // Browser view is detached from its widget during destruction. Cache the
   // window pointer so |this| can stop observing during destruction.
   native_window_ = widget_->GetNativeWindow();
   top_container_ = top_container;
-
-  // Optionally allow the tab indicators to be hidden.
-  if (CommandLine::ForCurrentProcess()->
-          HasSwitch(ash::switches::kAshImmersiveHideTabIndicators)) {
-    tab_indicator_visibility_ = TAB_INDICATORS_FORCE_HIDE;
-  }
 }
 
 void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
   DCHECK(native_window_) << "Must initialize before enabling";
   if (enabled_ == enabled)
     return;
   enabled_ = enabled;
 
   EnableWindowObservers(enabled_);
 
-  UpdateUseMinimalChrome(LAYOUT_NO);
+  if (enabled_) {
+    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.) This call has the side effect of relaying
     // out |browser_view_|'s root view.
     MaybeStartReveal(ANIMATE_NO);
 
     // Reset the located event and the focus revealed locks so that they do not
@@ skipping 22 matching lines @@
     // out.
     LayoutBrowserRootView();
   }
 }
 
 bool ImmersiveModeControllerAsh::IsEnabled() const {
   return enabled_;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTabIndicators() const {
-  return tab_indicator_visibility_ != TAB_INDICATORS_SHOW;
+  return ash::wm::GetWindowState(native_window_)->fullscreen_type() !=
+      ash::wm::FULLSCREEN_TYPE_IMMERSIVE_MINIMAL_CHROME;
 }
 
 bool ImmersiveModeControllerAsh::ShouldHideTopViews() const {
   return enabled_ && reveal_state_ == CLOSED;
 }
 
 bool ImmersiveModeControllerAsh::IsRevealed() const {
   return enabled_ && reveal_state_ != CLOSED;
 }
 
@@ skipping 207 matching lines @@
 
 void ImmersiveModeControllerAsh::OnRemoveTransientChild(
     aura::Window* window,
     aura::Window* transient) {
   bubble_manager_->StopObserving(transient);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Testing interface:
 
-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(top_container_, hovered);
   UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
 }
 
 void ImmersiveModeControllerAsh::SetMouseHoveredForTest(bool hovered) {
   MoveMouse(top_container_, hovered);
   UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
 }
@@ skipping 270 matching lines @@
 
       // Ending the reveal was unsuccessful. Reaquire the locks if appropriate.
       UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
       UpdateFocusRevealedLock();
     }
   }
   return false;
 }
 
 void ImmersiveModeControllerAsh::UpdateUseMinimalChrome(Layout layout) {
+  if (!enabled_)
+    return;
+
+  ash::wm::FullscreenType previous_fullscreen_type =
+      ash::wm::GetWindowState(native_window_)->fullscreen_type();
+
   // May be NULL in tests.
   FullscreenController* fullscreen_controller =
       delegate_->GetFullscreenController();
   bool in_tab_fullscreen = fullscreen_controller ?
       fullscreen_controller->IsFullscreenForTabOrPending() : false;
-  bool use_minimal_chrome = !in_tab_fullscreen && enabled_;
-  native_window_->SetProperty(ash::internal::kFullscreenUsesMinimalChromeKey,
-                              use_minimal_chrome);
+  ash::wm::FullscreenType fullscreen_type = in_tab_fullscreen ?
+      ash::wm::FULLSCREEN_TYPE_IMMERSIVE_NO_CHROME :
+      ash::wm::FULLSCREEN_TYPE_IMMERSIVE_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;
-  }
+  if (fullscreen_type == previous_fullscreen_type)
+    return;
+  ash::wm::GetWindowState(native_window_)->SetFullscreenType(fullscreen_type);
 
   // 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)
-      LayoutBrowserRootView();
-  }
+  // 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)
+    LayoutBrowserRootView();
 }
 
 int ImmersiveModeControllerAsh::GetAnimationDuration(Animate animate) const {
   switch (animate) {
     case ANIMATE_NO:
       return 0;
     case ANIMATE_SLOW:
       return kRevealSlowAnimationDurationMs;
     case ANIMATE_FAST:
       return kRevealFastAnimationDurationMs;
@@ skipping 205 matching lines @@
     aura::Window* transient_child = transient_children[i];
     views::BubbleDelegateView* bubble_delegate =
         AsBubbleDelegate(transient_child);
     if (bubble_delegate &&
         bubble_delegate->GetAnchorView() &&
         top_container_->Contains(bubble_delegate->GetAnchorView())) {
       bubble_manager_->StartObserving(transient_child);
     }
   }
 }