Refactor backdrop that is currently used in the maximized 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 <algorithm>
 
 #include "ash/keyboard/keyboard_observer_register.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_controller.h"
 #include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/fullscreen_window_finder.h"
 #include "ash/wm/screen_pinning_controller.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
-#include "ash/wm/workspace/workspace_layout_manager_backdrop_delegate.h"
+#include "ash/wm/workspace/backdrop_controller.h"
+#include "ash/wm/workspace/backdrop_delegate.h"
 #include "ash/wm_window.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(aura::Window* window)
     : window_(window),
       root_window_(window->GetRootWindow()),
       root_window_controller_(RootWindowController::ForWindow(root_window_)),
       work_area_in_parent_(
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_)),
       is_fullscreen_(wm::GetWindowForFullscreenMode(window) != nullptr),
       keyboard_observer_(this) {
   Shell::Get()->AddShellObserver(this);
   Shell::Get()->activation_client()->AddObserver(this);
   root_window_->AddObserver(this);
   display::Screen::GetScreen()->AddObserver(this);
   DCHECK(window->GetProperty(kSnapChildrenToPixelBoundary));
+  backdrop_controller_ = base::MakeUnique<BackdropController>(window_);
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
   if (root_window_)
     root_window_->RemoveObserver(this);
   for (aura::Window* window : windows_) {
     wm::WindowState* window_state = wm::GetWindowState(window);
     window_state->RemoveObserver(this);
     window->RemoveObserver(this);
   }
   display::Screen::GetScreen()->RemoveObserver(this);
   Shell::Get()->activation_client()->RemoveObserver(this);
   Shell::Get()->RemoveShellObserver(this);
 }
 
-void WorkspaceLayoutManager::SetMaximizeBackdropDelegate(
-    std::unique_ptr<WorkspaceLayoutManagerBackdropDelegate> delegate) {
-  backdrop_delegate_ = std::move(delegate);
+void WorkspaceLayoutManager::SetBackdropDelegate(
+    std::unique_ptr<BackdropDelegate> delegate) {
+  backdrop_controller_->SetBackdropDelegate(std::move(delegate));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::LayoutManager implementation:
 
 void WorkspaceLayoutManager::OnWindowResized() {}
 
 void WorkspaceLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   wm::WMEvent event(wm::WM_EVENT_ADDED_TO_WORKSPACE);
   window_state->OnWMEvent(&event);
   windows_.insert(child);
   child->AddObserver(this);
   window_state->AddObserver(this);
   UpdateShelfVisibility();
   UpdateFullscreenState();
-  if (backdrop_delegate_)
-    backdrop_delegate_->OnWindowAddedToLayout(WmWindow::Get(child));
+
+  backdrop_controller_->OnWindowAddedToLayout(child);
   WindowPositioner::RearrangeVisibleWindowOnShow(WmWindow::Get(child));
   if (Shell::Get()->screen_pinning_controller()->IsPinned())
     wm::GetWindowState(child)->DisableAlwaysOnTop(nullptr);
 }
 
 void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   windows_.erase(child);
   child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
 
   if (child->layer()->GetTargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(
         WmWindow::Get(child));
 }
 
 void WorkspaceLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
   UpdateShelfVisibility();
   UpdateFullscreenState();
-  if (backdrop_delegate_)
-    backdrop_delegate_->OnWindowRemovedFromLayout(WmWindow::Get(child));
+  backdrop_controller_->OnWindowRemovedFromLayout(child);
 }
 
 void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(aura::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->layer()->GetTargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnShow(WmWindow::Get(child));
   else
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(
         WmWindow::Get(child));
   UpdateFullscreenState();
   UpdateShelfVisibility();
-  if (backdrop_delegate_) {
-    backdrop_delegate_->OnChildWindowVisibilityChanged(WmWindow::Get(child),
-                                                       visible);
-  }
+  backdrop_controller_->OnChildWindowVisibilityChanged(child, visible);
 }
 
 void WorkspaceLayoutManager::SetChildBounds(aura::Window* child,
                                             const gfx::Rect& requested_bounds) {
   wm::SetBoundsEvent event(wm::WM_EVENT_SET_BOUNDS, requested_bounds);
   wm::GetWindowState(child)->OnWMEvent(&event);
   UpdateShelfVisibility();
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 70 matching lines @@
   // the fullscreen state accordingly.
   if (params.new_parent && params.new_parent->GetRootWindow() == root_window_) {
     UpdateFullscreenState();
     UpdateShelfVisibility();
   }
 }
 
 void WorkspaceLayoutManager::OnWindowPropertyChanged(aura::Window* window,
                                                      const void* key,
                                                      intptr_t old) {
-  if (key == aura::client::kAlwaysOnTopKey &&
-      window->GetProperty(aura::client::kAlwaysOnTopKey)) {
-    aura::Window* container =
-        root_window_controller_->always_on_top_controller()
-            ->GetContainer(WmWindow::Get(window))
-            ->aura_window();
-    if (window->parent() != container)
-      container->AddChild(window);
+  if (key == aura::client::kAlwaysOnTopKey) {
+    if (window->GetProperty(aura::client::kAlwaysOnTopKey)) {
+      aura::Window* container =
+          root_window_controller_->always_on_top_controller()
+              ->GetContainer(WmWindow::Get(window))
+              ->aura_window();
+      if (window->parent() != container)
+        container->AddChild(window);
+    }
+  } else if (key == aura::client::kHasBackdrop) {
+    backdrop_controller_->UpdateBackdrop();
   }
 }
 
 void WorkspaceLayoutManager::OnWindowStackingChanged(aura::Window* window) {
   UpdateShelfVisibility();
   UpdateFullscreenState();
-  if (backdrop_delegate_)
-    backdrop_delegate_->OnWindowStackingChanged(WmWindow::Get(window));
+  backdrop_controller_->OnWindowStackingChanged(window);
 }
 
 void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = nullptr;
   }
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(
@@ skipping 30 matching lines @@
 void WorkspaceLayoutManager::OnPostWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old_type) {
   // Notify observers that fullscreen state may be changing.
   if (window_state->IsFullscreen() ||
       old_type == wm::WINDOW_STATE_TYPE_FULLSCREEN) {
     UpdateFullscreenState();
   }
 
   UpdateShelfVisibility();
-  if (backdrop_delegate_)
-    backdrop_delegate_->OnPostWindowStateTypeChange(window_state, old_type);
+  backdrop_controller_->OnPostWindowStateTypeChange(window_state, old_type);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, display::DisplayObserver implementation:
 
 void WorkspaceLayoutManager::OnDisplayMetricsChanged(
     const display::Display& display,
     uint32_t changed_metrics) {
   if (display::Screen::GetScreen()->GetDisplayNearestWindow(window_).id() !=
       display.id()) {
@@ skipping 106 matching lines @@
   for (aura::Window* window : windows) {
     wm::WindowState* window_state = wm::GetWindowState(window);
     if (window_on_top)
       window_state->DisableAlwaysOnTop(WmWindow::Get(window_on_top));
     else
       window_state->RestoreAlwaysOnTop();
   }
 }
 
 }  // namespace ash