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 200 matching lines @@
                                                      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) {
   UpdateShelfVisibility();
-  UpdateFullscreenState();

[oshima, 2014/02/14 20:09:30]

I think this one should stay here. Technically it's possible to move the
fullscreen window to topmost on another display without changing activation ,
right?

[flackr, 2014/02/14 20:15:01]

Correct, but this calls OnWindowRemovedFromLayout on the current layout manager
and OnWindowAddedToLayout on the new layout manager.

 }
 
 void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = NULL;
   }
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(aura::Window* window,
                                               const gfx::Rect& old_bounds,
                                               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) {

[oshima, 2014/02/14 17:24:26]

can you fix indent?

[flackr, 2014/02/14 20:00:02]

Done.

   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();

[oshima, 2014/02/14 17:24:26]

All layout managers are notified for activation change, aren't they?

I think this is one thing I overlooked when I merged BaseLayoutManager and right
fix is to observe only events that needs. Better short term fix may be

if (!shelf_)
  return;

in UpdateFullscreenState(). WDYT?

[flackr, 2014/02/14 20:00:02]

Yes, since it's a ShellObserver notification, that's why I had to make the
change in UpdateFullscreenState.
That sounds nicer in the meantime, done. Thanks!

 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, wm::WindowStateObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowShowTypeChanged(
     wm::WindowState* window_state,
     wm::WindowShowType old_type) {
   if (old_type != wm::SHOW_TYPE_MINIMIZED &&
       !window_state->HasRestoreBounds() &&
@@ skipping 158 matching lines @@
   if (window->bounds() != bounds)
     window->SetBounds(bounds);
 }
 
 void WorkspaceLayoutManager::UpdateShelfVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
 void WorkspaceLayoutManager::UpdateFullscreenState() {
-  bool is_fullscreen = GetRootWindowController(
-      window_->GetRootWindow())->GetWindowForFullscreenMode() != NULL;
+  const aura::Window* fullscreen_window = GetRootWindowController(
+      window_->GetRootWindow())->GetWindowForFullscreenMode();
+  // 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 so
+  // this should correctly track the root window fullscreen state but this
+  // should really be tracked by the RootWindowController since technically
+  // any container could get a fullscreen window.
+  bool is_fullscreen = fullscreen_window &&
+                       window_->Contains(fullscreen_window);
   if (is_fullscreen != is_fullscreen_) {
     ash::Shell::GetInstance()->NotifyFullscreenStateChange(
         is_fullscreen, window_->GetRootWindow());
     is_fullscreen_ = is_fullscreen;
   }
 }
 
 void WorkspaceLayoutManager::UpdateBoundsFromShowType(
     wm::WindowState* window_state,
     wm::WindowShowType old_show_type) {
@@ skipping 96 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