[Refactor] Replace kFullscreenUsesMinimalChromeKey with WindowState::hide_shelf_when_fullscreen()

ash/wm/window_state.cc

 // Copyright 2013 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 "ash/wm/window_state.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_properties.h"
@@ skipping 10 matching lines @@
 namespace wm {
 
 // static
 bool WindowState::IsMaximizedOrFullscreenState(ui::WindowShowState show_state) {
   return show_state == ui::SHOW_STATE_FULLSCREEN ||
       show_state == ui::SHOW_STATE_MAXIMIZED;
 }
 
 WindowState::WindowState(aura::Window* window)
     : window_(window),
+      fullscreen_type_(FULLSCREEN_TYPE_DEFAULT),
       tracked_by_workspace_(true),
       window_position_managed_(false),
       bounds_changed_by_user_(false),
       panel_attached_(true),
       continue_drag_after_reparent_(false),
       ignored_by_shelf_(false),
       can_consume_system_keys_(false),
       top_row_keys_are_function_keys_(false),
       always_restores_to_restore_bounds_(false),
       window_show_type_(ToWindowShowType(GetShowState())) {
@@ skipping 12 matching lines @@
 }
 
 bool WindowState::IsMaximized() const {
   return GetShowState() == ui::SHOW_STATE_MAXIMIZED;
 }
 
 bool WindowState::IsFullscreen() const {
   return GetShowState() == ui::SHOW_STATE_FULLSCREEN;
 }
 
+bool WindowState::IsImmersiveFullscreen() const {
+  if (!IsFullscreen())
+    return false;
+  return fullscreen_type_ == FULLSCREEN_TYPE_IMMERSIVE_MINIMAL_CHROME ||
+      fullscreen_type_ == FULLSCREEN_TYPE_IMMERSIVE_NO_CHROME;
+}
+
 bool WindowState::IsMaximizedOrFullscreen() const {
   return IsMaximizedOrFullscreenState(GetShowState());
 }
 
 bool WindowState::IsNormalShowState() const {
   ui::WindowShowState state = window_->GetProperty(aura::client::kShowStateKey);
   return state == ui::SHOW_STATE_NORMAL || state == ui::SHOW_STATE_DEFAULT;
 }
 
 bool WindowState::IsActive() const {
@@ skipping 111 matching lines @@
 
 void WindowState::SetRestoreBoundsInParent(const gfx::Rect& bounds) {
   SetRestoreBoundsInScreen(
       ScreenAsh::ConvertRectToScreen(window_->parent(), bounds));
 }
 
 void WindowState::ClearRestoreBounds() {
   window_->ClearProperty(aura::client::kRestoreBoundsKey);
 }
 
+void WindowState::SetFullscreenType(FullscreenType type) {
+  if (!IsFullscreen())
+    return;
+  fullscreen_type_ = type;
+}
+
 void WindowState::SetPreAutoManageWindowBounds(
     const gfx::Rect& bounds) {
   pre_auto_manage_window_bounds_.reset(new gfx::Rect(bounds));
 }
 
 void WindowState::AddObserver(WindowStateObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void WindowState::RemoveObserver(WindowStateObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void WindowState::SetTrackedByWorkspace(bool tracked_by_workspace) {
   if (tracked_by_workspace_ == tracked_by_workspace)
     return;
   bool old = tracked_by_workspace_;
   tracked_by_workspace_ = tracked_by_workspace;
   FOR_EACH_OBSERVER(WindowStateObserver, observer_list_,
                     OnTrackedByWorkspaceChanged(this, old));
 }
 
 void WindowState::OnWindowPropertyChanged(aura::Window* window,
                                           const void* key,
                                           intptr_t old) {
   DCHECK_EQ(window, window_);
   if (key == aura::client::kShowStateKey) {
     window_show_type_ = ToWindowShowType(GetShowState());
+    if (window_show_type_ != ash::wm::SHOW_TYPE_FULLSCREEN &&
+        window_show_type_ != ash::wm::SHOW_TYPE_MINIMIZED) {
+      fullscreen_type_ = FULLSCREEN_TYPE_DEFAULT;
+    }
+
     ui::WindowShowState old_state = static_cast<ui::WindowShowState>(old);
     // TODO(oshima): Notify only when the state has changed.
     // Doing so break a few tests now.
     FOR_EACH_OBSERVER(
         WindowStateObserver, observer_list_,
         OnWindowShowTypeChanged(this, ToWindowShowType(old_state)));
   }
 }
 
 void WindowState::OnWindowDestroying(aura::Window* window) {
@@ skipping 37 matching lines @@
   }
   return settings;
 }
 
 const WindowState* GetWindowState(const aura::Window* window) {
   return GetWindowState(const_cast<aura::Window*>(window));
 }
 
 }  // namespace wm
 }  // namespace ash