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 76 matching lines @@
   UpdateFullscreenState();
 }
 
 void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(Window* child,
                                                             bool visible) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   // Attempting to show a minimized window. Unminimize it.
   if (visible && window_state->IsMinimized())
     window_state->Unminimize();
 
-  if (child->TargetVisibility()) {
+  if (child->TargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnShow(child);
-  } else {
-    if (wm::GetWindowState(child)->IsFullscreen())
-      UpdateFullscreenState();
+  else
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
-  }
+  UpdateFullscreenState();
   UpdateShelfVisibility();
 }
 
 void WorkspaceLayoutManager::SetChildBounds(
     Window* child,
     const gfx::Rect& requested_bounds) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   window_state->RequestBounds(requested_bounds);
   UpdateShelfVisibility();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, ash::ShellObserver implementation:
 
 void WorkspaceLayoutManager::OnDisplayWorkAreaInsetsChanged() {
   const gfx::Rect work_area(ScreenUtil::ConvertRectFromScreen(
       window_,
       Shell::GetScreen()->GetDisplayNearestWindow(window_).work_area()));
   if (work_area != work_area_in_parent_)
     AdjustAllWindowsBoundsForWorkAreaChange(wm::WORKAREA_BOUNDS_CHANGED);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::WindowObserver implementation:
 
+void WorkspaceLayoutManager::OnWindowHierarchyChanged(
+    const WindowObserver::HierarchyChangeParams& params) {
+  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 21 matching lines @@
 // aura::client::ActivationChangeObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowActivated(aura::Window* gained_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();
+  UpdateShelfVisibility();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, wm::WindowStateObserver implementation:
 
 void WorkspaceLayoutManager::OnPostWindowShowTypeChange(
     wm::WindowState* window_state,
     wm::WindowShowType old_type) {
 
   // Notify observers that fullscreen state may be changing.
@@ skipping 33 matching lines @@
     wm::GetWindowState(*it)->OnWMEvent(event);
   }
 }
 
 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;
   }
 }
 
 }  // namespace internal
 }  // namespace ash