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

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"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace/workspace_layout_manager_backdrop.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/corewm/window_util.h"
 
@@ skipping 23 matching lines @@
   for (WindowSet::const_iterator i = windows_.begin(); i != windows_.end(); ++i)
     (*i)->RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
   Shell::GetInstance()->activation_client()->RemoveObserver(this);
 }
 
 void WorkspaceLayoutManager::SetShelf(internal::ShelfLayoutManager* shelf) {
   shelf_ = shelf;
 }
 
+void WorkspaceLayoutManager::AddBackdropBehindTopWindow(bool enable) {
+  if ((NULL != backdrop_.get()) == enable)

[sky, 2014/03/06 01:03:18]

nit: creating a local variable for NULL != backdrop_.get() is a lot more
readable.

[Mr4D (OOO till 08-26), 2014/03/06 17:17:16]

Done.

+    return;
+  if (enable)
+    backdrop_.reset(new WorkspaceLayoutManagerBackdrop(window_));
+  else
+    backdrop_.reset();
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::LayoutManager implementation:
 
 void WorkspaceLayoutManager::OnWindowAddedToLayout(Window* child) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   window_state->OnWMEvent(wm::ADDED_TO_WORKSPACE);
   windows_.insert(child);
   child->AddObserver(this);
   window_state->AddObserver(this);
   UpdateShelfVisibility();
   UpdateFullscreenState();
+  UpdateStackingAndVisibilityOfBackdrop();

[sky, 2014/03/06 01:03:18]

How about a delegate method that is called at all these places? That way
WorskpaceLayoutManager does't have to own the backdrop_ or know anything about
it.

[Mr4D (OOO till 08-26), 2014/03/06 17:17:16]

Done.

   WindowPositioner::RearrangeVisibleWindowOnShow(child);
 }
 
 void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(Window* child) {
   windows_.erase(child);
   child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
 
   if (child->TargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
 }
 
 void WorkspaceLayoutManager::OnWindowRemovedFromLayout(Window* child) {
   UpdateShelfVisibility();
   UpdateFullscreenState();
+  UpdateStackingAndVisibilityOfBackdrop();
 }
 
 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()) {
     WindowPositioner::RearrangeVisibleWindowOnShow(child);
   } else {
     if (wm::GetWindowState(child)->IsFullscreen())
       UpdateFullscreenState();
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
   }
   UpdateShelfVisibility();
+  UpdateStackingAndVisibilityOfBackdrop();
 }
 
 void WorkspaceLayoutManager::SetChildBounds(
     Window* child,
     const gfx::Rect& requested_bounds) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   window_state->RequestBounds(requested_bounds);
   UpdateShelfVisibility();
 }
 
@@ skipping 17 matching lines @@
   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();
+  UpdateStackingAndVisibilityOfBackdrop();
 }
 
 void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = NULL;
   }
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(aura::Window* window,
@@ skipping 22 matching lines @@
 
 void WorkspaceLayoutManager::OnPostWindowShowTypeChange(
     wm::WindowState* window_state,
     wm::WindowShowType old_type) {
 
   // Notify observers that fullscreen state may be changing.
   if (window_state->IsFullscreen() || old_type == wm::SHOW_TYPE_FULLSCREEN)
     UpdateFullscreenState();
 
   UpdateShelfVisibility();
+  UpdateStackingAndVisibilityOfBackdrop();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, private:
 
 void WorkspaceLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(
     wm::WMEvent event) {
   DCHECK(event == wm::DISPLAY_BOUNDS_CHANGED ||
          event == wm::WORKAREA_BOUNDS_CHANGED);
 
@@ skipping 18 matching lines @@
        ++it) {
     wm::GetWindowState(*it)->OnWMEvent(event);
   }
 }
 
 void WorkspaceLayoutManager::UpdateShelfVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
+void WorkspaceLayoutManager::UpdateStackingAndVisibilityOfBackdrop() {
+  if (backdrop_)
+    backdrop_->RestackOrHideWindow();
+}
+
 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;
   }
 }
 
 }  // namespace internal
 }  // namespace ash