Refactors DimWindow and moves to ash/common

ash/wm/system_modal_container_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/system_modal_container_layout_manager.h"
 
 #include <cmath>
 
+#include "ash/aura/wm_window_aura.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/window_dimmer.h"
 #include "ash/common/wm_shell.h"
 #include "ash/shell.h"
-#include "ash/wm/dim_window.h"
 #include "ash/wm/window_util.h"
 #include "base/stl_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/layer.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace {
 
 // The center point of the window can diverge this much from the center point
 // If this is set to true, the window will get centered.
 DEFINE_WINDOW_PROPERTY_KEY(bool, kCenteredKey, false);
 
 // The center point of the window can diverge this much from the center point
 // of the container to be kept centered upon resizing operations.
 const int kCenterPixelDelta = 32;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SystemModalContainerLayoutManager, public:
 
 SystemModalContainerLayoutManager::SystemModalContainerLayoutManager(
     aura::Window* container)
-    : SnapToPixelLayoutManager(container),
-      container_(container),
-      modal_background_(nullptr) {}
+    : SnapToPixelLayoutManager(container), container_(container) {}
 
 SystemModalContainerLayoutManager::~SystemModalContainerLayoutManager() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // SystemModalContainerLayoutManager, aura::LayoutManager implementation:
 
 void SystemModalContainerLayoutManager::OnWindowResized() {
   PositionDialogsAfterWorkAreaResize();
 }
 
 void SystemModalContainerLayoutManager::OnWindowAddedToLayout(
     aura::Window* child) {
-  DCHECK(child == modal_background_ ||
-         child->type() == ui::wm::WINDOW_TYPE_NORMAL ||
+  DCHECK(child->type() == ui::wm::WINDOW_TYPE_NORMAL ||
          child->type() == ui::wm::WINDOW_TYPE_POPUP);
   DCHECK(
       container_->id() != kShellWindowId_LockSystemModalContainer ||
       WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked());
   // Since this is for SystemModal, there is no goodd reason to add
   // these window other than MODAL_TYPE_NONE or MODAL_TYPE_SYSTEM.
   // DCHECK to avoid simple mistake.
   DCHECK_NE(child->GetProperty(aura::client::kModalKey), ui::MODAL_TYPE_CHILD);
   DCHECK_NE(child->GetProperty(aura::client::kModalKey), ui::MODAL_TYPE_WINDOW);
 
@@ skipping 33 matching lines @@
     return;
 
   if (new_modal == ui::MODAL_TYPE_SYSTEM) {
     AddModalWindow(window);
   } else {
     RemoveModalWindow(window);
     Shell::GetInstance()->OnModalWindowRemoved(window);
   }
 }
 
-void SystemModalContainerLayoutManager::OnWindowDestroying(
-    aura::Window* window) {
-  if (modal_background_ == window) {
-    if (keyboard::KeyboardController::GetInstance())
-      keyboard::KeyboardController::GetInstance()->RemoveObserver(this);
-    modal_background_ = nullptr;
-  }
-}
-
 void SystemModalContainerLayoutManager::OnWindowVisibilityChanged(
     aura::Window* window,
     bool visible) {
   if (window->GetProperty(aura::client::kModalKey) != ui::MODAL_TYPE_SYSTEM)
     return;
   if (window->IsVisible()) {
     AddModalWindow(window);
   } else {
     RemoveModalWindow(window);
     Shell::GetInstance()->OnModalWindowRemoved(window);
@@ skipping 18 matching lines @@
 }
 
 bool SystemModalContainerLayoutManager::ActivateNextModalWindow() {
   if (modal_windows_.empty())
     return false;
   wm::ActivateWindow(modal_window());
   return true;
 }
 
 void SystemModalContainerLayoutManager::CreateModalBackground() {
-  if (!modal_background_) {
-    modal_background_ = new DimWindow(container_);
-    modal_background_->SetName(
+  if (!window_dimmer_) {
+    window_dimmer_ =
+        base::MakeUnique<WindowDimmer>(WmWindowAura::Get(container_));
+    window_dimmer_->window()->SetName(
         "SystemModalContainerLayoutManager.ModalBackground");
     // There isn't always a keyboard controller.
     if (keyboard::KeyboardController::GetInstance())
       keyboard::KeyboardController::GetInstance()->AddObserver(this);
   }
-  modal_background_->Show();
+  window_dimmer_->window()->Show();
 }
 
 void SystemModalContainerLayoutManager::DestroyModalBackground() {
-  // modal_background_ can be NULL when a root window is shutting down.
-  if (modal_background_) {
-    if (keyboard::KeyboardController::GetInstance())
-      keyboard::KeyboardController::GetInstance()->RemoveObserver(this);
-    modal_background_->Hide();
-    // Explicitly delete instead of using scoped_ptr as the owner of the
-    // window is its parent.
-    delete modal_background_;
-    modal_background_ = nullptr;
-  }
+  if (!window_dimmer_)
+    return;
+
+  if (keyboard::KeyboardController::GetInstance())
+    keyboard::KeyboardController::GetInstance()->RemoveObserver(this);
+  window_dimmer_.reset();
 }
 
 // static
 bool SystemModalContainerLayoutManager::IsModalBackground(
     aura::Window* window) {
   int id = window->parent()->id();
   if (id != kShellWindowId_SystemModalContainer &&
       id != kShellWindowId_LockSystemModalContainer)
     return false;
   SystemModalContainerLayoutManager* layout_manager =
       static_cast<SystemModalContainerLayoutManager*>(
           window->parent()->layout_manager());
-  return layout_manager->modal_background_ == window;
+  return layout_manager->window_dimmer_ &&
+         layout_manager->window_dimmer_->window() == WmWindowAura::Get(window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SystemModalContainerLayoutManager, private:
 
 void SystemModalContainerLayoutManager::AddModalWindow(aura::Window* window) {
   if (modal_windows_.empty()) {
     aura::Window* capture_window = aura::client::GetCaptureWindow(container_);
     if (capture_window)
       capture_window->ReleaseCapture();
@@ skipping 69 matching lines @@
 bool SystemModalContainerLayoutManager::DialogIsCentered(
     const gfx::Rect& window_bounds) {
   gfx::Point window_center = window_bounds.CenterPoint();
   gfx::Point container_center = GetUsableDialogArea().CenterPoint();
   return std::abs(window_center.x() - container_center.x()) <
              kCenterPixelDelta &&
          std::abs(window_center.y() - container_center.y()) < kCenterPixelDelta;
 }
 
 }  // namespace ash