Use active window if on current workspace 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_util.h"
 #include "ash/session_state_delegate.h"
@@ skipping 138 matching lines @@
       Shell::GetScreen()->GetDisplayNearestWindow(window_).work_area()));
   if (work_area != work_area_in_parent_) {
     AdjustAllWindowsBoundsForWorkAreaChange(
         ADJUST_WINDOW_WORK_AREA_INSETS_CHANGED);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::WindowObserver implementation:
 
+void WorkspaceLayoutManager::OnWindowHierarchyChanged(
+    const WindowObserver::HierarchyChangeParams& params) {

[oshima, 2014/02/21 19:49:46]

A display may become fullscreen when the fullscreen became topmost as a result
of closing another window. Are we handling this case?

[flackr, 2014/02/24 16:21:10]

Yes, if an active window (i.e. panel) is preventing fullscreen and it closes it
will cause an activation change (possibly to NULL) which will call
UpdateFullscreenState. If a window in the container (active or not) is
preventing fullscreen (i.e. it is above the fullscreen window), it will call
UpdateFullscreen in OnWindowRemovedFromLayout.

+  if (!wm::GetWindowState(params.target)->IsActive())
+    return;
+  // If the window is already tracked by the workspace this update would be
+  // redundant as the fullscreen and shelf state would have been handled in
+  // OnWindowAddedToLayout.
+  if (windows_.find(params.target) != windows_.end())
+    return;
+
+  // If the active window has moved to this root window then update the
+  // fullscreen state.
+  // TODO(flackr): Track the active window leaving this root window and update
+  // the fullscreen state accordingly.
+  if (params.new_parent && params.new_parent->GetRootWindow() == root_window_) {
+    UpdateFullscreenState();
+    UpdateShelfVisibility();
+  }
+}
+
 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);
   }
 }
 
@@ skipping 14 matching lines @@
                                               const gfx::Rect& new_bounds) {
   if (root_window_ == window)
     AdjustAllWindowsBoundsForWorkAreaChange(ADJUST_WINDOW_DISPLAY_SIZE_CHANGED);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager,
 // aura::client::ActivationChangeObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowActivated(aura::Window* gained_active,
-                                          aura::Window* lost_active) {
+                                               aura::Window* lost_active) {
   wm::WindowState* window_state = wm::GetWindowState(gained_active);
   if (window_state && window_state->IsMinimized() &&
       !gained_active->IsVisible()) {
     window_state->Unminimize();
     DCHECK(!window_state->IsMinimized());
   }
+  UpdateFullscreenState();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, wm::WindowStateObserver implementation:
 
 void WorkspaceLayoutManager::OnPostWindowShowTypeChange(
     wm::WindowState* window_state,
     wm::WindowShowType old_type) {
 
   // Notify observers that fullscreen state may be changing.
@@ skipping 99 matching lines @@
   if (window->bounds() != bounds)
     window->SetBounds(bounds);
 }
 
 void WorkspaceLayoutManager::UpdateShelfVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
 void WorkspaceLayoutManager::UpdateFullscreenState() {
+  // TODO(flackr): The fullscreen state is currently tracked per workspace
+  // but the shell notification implies a per root window state. Currently
+  // only windows in the default workspace container will go fullscreen but
+  // this should really be tracked by the RootWindowController since
+  // technically any container could get a fullscreen window.
+  if (!shelf_)
+    return;
   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;
   }
 }
 
 bool WorkspaceLayoutManager::SetMaximizedOrFullscreenBounds(
@@ skipping 10 matching lines @@
     SetChildBoundsDirect(
         window_state->window(),
         ScreenUtil::GetDisplayBoundsInParent(window_state->window()));
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace ash