Ignore fullscreen windows which are behind other windows for fullscreen mode.

ash/wm/workspace/workspace_layout_manager.cc

 // 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.
 
 #include "ash/wm/workspace/workspace_layout_manager.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 54 matching lines @@
   }
 }
 
 }  // namespace
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(aura::Window* window)
     : BaseLayoutManager(window->GetRootWindow()),
       shelf_(NULL),
       window_(window),
       work_area_in_parent_(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
-          window->parent())) {
+          window->parent())),
+      is_fullscreen_(GetRootWindowController(
+          window->GetRootWindow())->GetWindowForFullscreenMode() != NULL) {
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
 }
 
 void WorkspaceLayoutManager::SetShelf(internal::ShelfLayoutManager* shelf) {
   shelf_ = shelf;
 }
 
 void WorkspaceLayoutManager::OnWindowAddedToLayout(Window* child) {
   AdjustWindowBoundsWhenAdded(wm::GetWindowState(child));
   BaseLayoutManager::OnWindowAddedToLayout(child);
-  UpdateDesktopVisibility();
+  UpdateShelfVisibility();
+  UpdateFullscreenState();
   WindowPositioner::RearrangeVisibleWindowOnShow(child);
 }
 
 void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(Window* child) {
   BaseLayoutManager::OnWillRemoveWindowFromLayout(child);
   if (child->TargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
 }
 
 void WorkspaceLayoutManager::OnWindowRemovedFromLayout(Window* child) {
   BaseLayoutManager::OnWindowRemovedFromLayout(child);
-  UpdateDesktopVisibility();
+  UpdateShelfVisibility();
+  UpdateFullscreenState();
 }
 
 void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(Window* child,
                                                             bool visible) {
   BaseLayoutManager::OnChildWindowVisibilityChanged(child, visible);
   if (child->TargetVisibility()) {
     WindowPositioner::RearrangeVisibleWindowOnShow(child);
   } else {
-    if (wm::GetWindowState(child)->IsFullscreen()) {
-      ash::Shell::GetInstance()->NotifyFullscreenStateChange(
-          false, child->GetRootWindow());
-    }
+    if (wm::GetWindowState(child)->IsFullscreen())
+      UpdateFullscreenState();
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
   }
-  UpdateDesktopVisibility();
+  UpdateShelfVisibility();
 }
 
 void WorkspaceLayoutManager::SetChildBounds(
     Window* child,
     const gfx::Rect& requested_bounds) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   if (window_state->is_dragged()) {
     SetChildBoundsDirect(child, requested_bounds);
   } else if (!SetMaximizedOrFullscreenBounds(window_state)) {
     // Some windows rely on this to set their initial bounds.
     // Non-maximized/full-screen windows have their size constrained to the
     // work-area.
     gfx::Rect child_bounds(requested_bounds);
     child_bounds.set_width(std::min(work_area_in_parent_.width(),
                                     child_bounds.width()));
     child_bounds.set_height(std::min(work_area_in_parent_.height(),
                                      child_bounds.height()));
     AdjustSnappedBounds(window_state, &child_bounds);
     SetChildBoundsDirect(child, child_bounds);
   }
-  UpdateDesktopVisibility();
+  UpdateShelfVisibility();
 }
 
 void WorkspaceLayoutManager::OnDisplayWorkAreaInsetsChanged() {
   const gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
       window_->parent()));
   if (work_area != work_area_in_parent_) {
     AdjustAllWindowsBoundsForWorkAreaChange(
         ADJUST_WINDOW_WORK_AREA_INSETS_CHANGED);
   }
 }
 
 void WorkspaceLayoutManager::OnWindowPropertyChanged(Window* window,
                                                      const void* key,
                                                      intptr_t old) {
   if (key == aura::client::kAlwaysOnTopKey &&
       window->GetProperty(aura::client::kAlwaysOnTopKey)) {
     GetRootWindowController(window->GetRootWindow())->
         always_on_top_controller()->GetContainer(window)->AddChild(window);
   }
 }
 
+void WorkspaceLayoutManager::OnWindowStackingChanged(aura::Window* window) {
+  BaseLayoutManager::OnWindowStackingChanged(window);
+  UpdateShelfVisibility();
+  UpdateFullscreenState();
+}
+
 void WorkspaceLayoutManager::OnWindowShowTypeChanged(
     wm::WindowState* window_state,
     wm::WindowShowType old_type) {
   ui::WindowShowState old_state = ToWindowShowState(old_type);
   ui::WindowShowState new_state = window_state->GetShowState();
   if (old_state != ui::SHOW_STATE_MINIMIZED &&
       !window_state->HasRestoreBounds() &&
       window_state->IsMaximizedOrFullscreen() &&
       !wm::WindowState::IsMaximizedOrFullscreenState(old_state)) {
     window_state->SaveCurrentBoundsForRestore();
   }
   // When restoring from a minimized state, we want to restore to the
   // previous (maybe L/R maximized) state. Since we do also want to keep the
   // restore rectangle, we set the restore rectangle to the rectangle we want
   // to restore to and restore it after we switched so that it is preserved.
   gfx::Rect restore;
   if (old_state == ui::SHOW_STATE_MINIMIZED &&
       (new_state == ui::SHOW_STATE_NORMAL ||
        new_state == ui::SHOW_STATE_DEFAULT) &&
       window_state->HasRestoreBounds() &&
       !window_state->always_restores_to_restore_bounds()) {
     restore = window_state->GetRestoreBoundsInScreen();
     window_state->SaveCurrentBoundsForRestore();
   }
   // Notify observers that fullscreen state may be changing.
   if (old_state != new_state &&
       (new_state == ui::SHOW_STATE_FULLSCREEN ||
        old_state == ui::SHOW_STATE_FULLSCREEN)) {
-    ash::Shell::GetInstance()->NotifyFullscreenStateChange(
-        new_state == ui::SHOW_STATE_FULLSCREEN,
-        window_state->window()->GetRootWindow());
+    UpdateFullscreenState();
   }
 
   UpdateBoundsFromShowState(window_state, old_state);
   ShowStateChanged(window_state, old_state);
 
   // Set the restore rectangle to the previously set restore rectangle.
   if (!restore.IsEmpty())
     window_state->SetRestoreBoundsInScreen(restore);
 }
 
 void WorkspaceLayoutManager::ShowStateChanged(
     wm::WindowState* state,
     ui::WindowShowState last_show_state) {
   BaseLayoutManager::ShowStateChanged(state, last_show_state);
-  UpdateDesktopVisibility();
+  UpdateShelfVisibility();
 }
 
 void WorkspaceLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(
     AdjustWindowReason reason) {
   work_area_in_parent_ =
       ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_->parent());
   BaseLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(reason);
 }
 
 void WorkspaceLayoutManager::AdjustWindowBoundsForWorkAreaChange(
@@ skipping 60 matching lines @@
   // moved.
   gfx::Rect display_area = ScreenAsh::GetDisplayBoundsInParent(window);
 
   ash::wm::AdjustBoundsToEnsureWindowVisibility(
       display_area, min_width, min_height, &bounds);
   AdjustSnappedBounds(window_state, &bounds);
   if (window->bounds() != bounds)
     window->SetBounds(bounds);
 }
 
-void WorkspaceLayoutManager::UpdateDesktopVisibility() {
+void WorkspaceLayoutManager::UpdateShelfVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
+void WorkspaceLayoutManager::UpdateFullscreenState() {
+  bool is_fullscreen = GetRootWindowController(
+      window_->GetRootWindow())->GetWindowForFullscreenMode() != NULL;
+  if (is_fullscreen != is_fullscreen_) {
+    ash::Shell::GetInstance()->NotifyFullscreenStateChange(
+        is_fullscreen, window_->GetRootWindow());
+    is_fullscreen_ = is_fullscreen;
+  }
+}
+
 void WorkspaceLayoutManager::UpdateBoundsFromShowState(
     wm::WindowState* window_state,
     ui::WindowShowState last_show_state) {
   aura::Window* window = window_state->window();
   // See comment in SetMaximizedOrFullscreenBounds() as to why we use parent in
   // these calculation.
   // TODO(varkha): Change the switch statement below to use wm::WindowShowType.
   switch (window_state->GetShowState()) {
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_NORMAL: {
@@ skipping 112 matching lines @@
   ui::ScopedLayerAnimationSettings slide_settings(layer->GetAnimator());
   slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   slide_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kBoundsChangeSlideDurationMs));
   SetChildBoundsDirect(child, bounds);
 }
 
 }  // namespace internal
 }  // namespace ash