Adding a gray semi transparent backdrop behind the topmost window within the default container

ash/wm/maximize_mode/maximize_mode_window_manager.cc

 // Copyright 2014 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/maximize_mode/maximize_mode_window_manager.h"
 
+#include "ash/root_window_controller.h"
 #include "ash/shell.h"
-#include "ash/switchable_windows.h"
+#include "ash/shell_window_ids.h"
+#include "ash/wm/maximize_mode/workspace_backdrop_delegate.h"
 #include "ash/wm/mru_window_tracker.h"
+#include "ash/wm/workspace_controller.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace internal {
 
 MaximizeModeWindowManager::~MaximizeModeWindowManager() {
+  Shell::GetInstance()->RemoveShellObserver(this);
   Shell::GetScreen()->RemoveObserver(this);
+  EnableBackdropBehindTopWindowOnEachDisplay(false);
   RemoveWindowCreationObservers();
   RestoreAllWindows();
 }
 
 int MaximizeModeWindowManager::GetNumberOfManagedWindows() {
   return initial_state_type_.size();
 }
 
+void MaximizeModeWindowManager::OnOverviewModeStarted() {
+  if (backdrops_hidden_)
+    return;
+
+  EnableBackdropBehindTopWindowOnEachDisplay(false);
+  backdrops_hidden_ = true;
+}
+
+void MaximizeModeWindowManager::OnOverviewModeEnded() {
+  if (!backdrops_hidden_)
+    return;
+
+  backdrops_hidden_ = false;
+  EnableBackdropBehindTopWindowOnEachDisplay(true);
+}
+
 void MaximizeModeWindowManager::OnWindowDestroying(aura::Window* window) {
   // If a known window gets destroyed we need to remove all knowledge about it.
   if (!IsContainerWindow(window))
     ForgetWindow(window);
 }
 
 void MaximizeModeWindowManager::OnWindowAdded(
     aura::Window* window) {
   // A window can get removed and then re-added by a drag and drop operation.
   if (IsContainerWindow(window->parent()) &&
@@ skipping 22 matching lines @@
 }
 
 void MaximizeModeWindowManager::OnDisplayAdded(const gfx::Display& display) {
   DisplayConfigurationChanged();
 }
 
 void MaximizeModeWindowManager::OnDisplayRemoved(const gfx::Display& display) {
   DisplayConfigurationChanged();
 }
 
-MaximizeModeWindowManager::MaximizeModeWindowManager() {
+MaximizeModeWindowManager::MaximizeModeWindowManager()
+      : backdrops_hidden_(false) {
+  // TODO(skuhne): Turn off the overview mode and full screen modes before
+  // entering the MaximzieMode.
   MaximizeAllWindows();
   AddWindowCreationObservers();
+  EnableBackdropBehindTopWindowOnEachDisplay(true);
   Shell::GetScreen()->AddObserver(this);
+  Shell::GetInstance()->AddShellObserver(this);
 }
 
 void MaximizeModeWindowManager::MaximizeAllWindows() {
   MruWindowTracker::WindowList windows =
       MruWindowTracker::BuildWindowList(false);
   // Add all existing Mru windows.
   for (MruWindowTracker::WindowList::iterator window = windows.begin();
       window != windows.end(); ++window) {
     MaximizeAndTrackWindow(*window);
   }
@@ skipping 21 matching lines @@
       // This window type should not be able to have a restore state set (since
       // it cannot maximize).
       DCHECK(!window_state->HasRestoreBounds());
       // Store the coordinates as restore coordinates.
       gfx::Rect initial_rect = window->bounds();
       if (window->parent())
         window_state->SetRestoreBoundsInParent(initial_rect);
       else
         window_state->SetRestoreBoundsInScreen(initial_rect);
       CenterWindow(window);
-      // TODO(skuhne): Add a background cover layer.
     } else {
       // Minimized windows can remain as they are.
       if (state != wm::WINDOW_STATE_TYPE_MINIMIZED)
         wm::GetWindowState(window)->Maximize();
     }
   }
   window_state->set_can_be_dragged(false);
 }
 
 void MaximizeModeWindowManager::RestoreAndForgetWindow(
     aura::Window* window) {
   wm::WindowStateType state = ForgetWindow(window);
   wm::WindowState* window_state = wm::GetWindowState(window);
   window_state->set_can_be_dragged(true);
   // Restore window if it can be restored.
   if (state != wm::WINDOW_STATE_TYPE_MAXIMIZED) {
     if (!CanMaximize(window)) {
-      // TODO(skuhne): Remove the background cover layer.
       if (window_state->HasRestoreBounds()) {
         // TODO(skuhne): If the system shuts down in maximized mode, the proper
         // restore coordinates should get saved.
         gfx::Rect initial_bounds =
             window->parent() ? window_state->GetRestoreBoundsInParent() :
                                window_state->GetRestoreBoundsInScreen();
         window_state->ClearRestoreBounds();
         // TODO(skuhne): The screen might have changed and we should make sure
         // that the bounds are in a visible area.
         window->SetBounds(initial_bounds);
@@ skipping 38 matching lines @@
       work_area.x() + (work_area.width() - window_size.width()) / 2,
       work_area.y() + (work_area.height() - window_size.height()) / 2,
       window_size.width(),
       window_size.height());
 
   window->SetBounds(window_bounds);
 }
 
 void MaximizeModeWindowManager::AddWindowCreationObservers() {
   DCHECK(observed_container_windows_.empty());
-  // Observe window activations and switchable containers on all root windows
-  // for newly created windows during overview.
+  // Observe window activations/creations in the default containers on all root
+  // windows.
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
-    for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
-      aura::Window* container = Shell::GetContainer(*iter,
-          kSwitchableWindowContainerIds[i]);
-      DCHECK(observed_container_windows_.find(container) ==
-                observed_container_windows_.end());
-      container->AddObserver(this);
-      observed_container_windows_.insert(container);
-    }
+    aura::Window* container = Shell::GetContainer(*iter,
+        internal::kShellWindowId_DefaultContainer);
+    DCHECK(observed_container_windows_.find(container) ==
+              observed_container_windows_.end());
+    container->AddObserver(this);
+    observed_container_windows_.insert(container);
   }
 }
 
 void MaximizeModeWindowManager::RemoveWindowCreationObservers() {
   for (std::set<aura::Window*>::iterator iter =
            observed_container_windows_.begin();
        iter != observed_container_windows_.end(); ++iter) {
     (*iter)->RemoveObserver(this);
   }
   observed_container_windows_.clear();
 }
 
 void MaximizeModeWindowManager::DisplayConfigurationChanged() {
+  EnableBackdropBehindTopWindowOnEachDisplay(false);
   RemoveWindowCreationObservers();
   AddWindowCreationObservers();
+  EnableBackdropBehindTopWindowOnEachDisplay(true);
 }
 
 bool MaximizeModeWindowManager::IsContainerWindow(aura::Window* window) {
   return observed_container_windows_.find(window) !=
              observed_container_windows_.end();
 }
 
+void MaximizeModeWindowManager::EnableBackdropBehindTopWindowOnEachDisplay(
+    bool enable) {
+  if (backdrops_hidden_)
+    return;
+  // Inform the WorkspaceLayoutManager that we want to show a backdrop behind
+  // the topmost window of its container.
+  Shell::RootWindowControllerList controllers =
+      Shell::GetAllRootWindowControllers();
+  for (Shell::RootWindowControllerList::iterator iter = controllers.begin();
+       iter != controllers.end(); ++iter) {
+    RootWindowController* controller = *iter;
+    aura::Window* container = Shell::GetContainer(
+        controller->root_window(),
+        internal::kShellWindowId_DefaultContainer);
+    controller->workspace_controller()->SetMaximizeBackdropDelegate(
+        scoped_ptr<WorkspaceLayoutManagerDelegate>(
+            enable ? new WorkspaceBackdropDelegate(container) : NULL));
+  }
+}
+
 }  // namespace internal
 }  // namespace ash