Renames WmWindowUserData and converts to using aura

ash/wm/screen_pinning_controller.cc

 // Copyright 2016 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/screen_pinning_controller.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/window_dimmer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_window.h"
-#include "ash/common/wm_window_user_data.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
+#include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace {
 
+DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(WindowDimmer, kWindowDimmerKey, nullptr);
+
 // Returns a list of WmWindows corresponding to SystemModalContainers,
 // except ones whose root is shared with |pinned_window|.
 std::vector<WmWindow*> GetSystemModalWindowsExceptPinned(
     WmWindow* pinned_window) {
   WmWindow* pinned_root = pinned_window->GetRootWindow();
 
   std::vector<WmWindow*> result;
-  for (WmWindow* system_modal : wm::GetContainersFromAllRootWindows(
+  for (aura::Window* system_modal : wm::GetContainersFromAllRootWindows(
            kShellWindowId_SystemModalContainer)) {
-    if (system_modal->GetRootWindow() == pinned_root)
+    if (WmWindow::Get(system_modal)->GetRootWindow() == pinned_root)
       continue;
-    result.push_back(system_modal);
+    result.push_back(WmWindow::Get(system_modal));
   }
   return result;
 }
 
 void AddObserverToChildren(WmWindow* container,
                            aura::WindowObserver* observer) {
   for (WmWindow* child : container->GetChildren()) {
     WmWindow::GetAuraWindow(child)->AddObserver(observer);
   }
 }
 
 void RemoveObserverFromChildren(WmWindow* container,
                                 aura::WindowObserver* observer) {
   for (WmWindow* child : container->GetChildren()) {
     WmWindow::GetAuraWindow(child)->RemoveObserver(observer);
   }
 }
 
+// Returns true if the WindowDimmer's window associated with |window| is
+// visible.
+bool IsWindowDimmerWindowVisible(aura::Window* window) {
+  // Expect this is only called for windows with a WindowDimmer.
+  DCHECK(window->GetProperty(kWindowDimmerKey));
+  return window->GetProperty(kWindowDimmerKey)
+      ->window()
+      ->layer()
+      ->GetTargetVisibility();
+}
+
 }  // namespace
 
 // Adapter to fire OnPinnedContainerWindowStackingChanged().
 class ScreenPinningController::PinnedContainerChildWindowObserver
     : public aura::WindowObserver {
  public:
   explicit PinnedContainerChildWindowObserver(
       ScreenPinningController* controller)
       : controller_(controller) {}
 
@@ skipping 69 matching lines @@
     window->RemoveObserver(this);
   }
 
  private:
   ScreenPinningController* controller_;
   DISALLOW_COPY_AND_ASSIGN(SystemModalContainerWindowObserver);
 };
 
 ScreenPinningController::ScreenPinningController(
     WindowTreeHostManager* window_tree_host_manager)
-    : window_dimmers_(base::MakeUnique<WmWindowUserData<WindowDimmer>>()),
-      window_tree_host_manager_(window_tree_host_manager),
+    : window_tree_host_manager_(window_tree_host_manager),
       pinned_container_window_observer_(
           base::MakeUnique<PinnedContainerWindowObserver>(this)),
       pinned_container_child_window_observer_(
           base::MakeUnique<PinnedContainerChildWindowObserver>(this)),
       system_modal_container_window_observer_(
           base::MakeUnique<SystemModalContainerWindowObserver>(this)),
       system_modal_container_child_window_observer_(
           base::MakeUnique<SystemModalContainerChildWindowObserver>(this)) {
   window_tree_host_manager_->AddObserver(this);
 }
 
 ScreenPinningController::~ScreenPinningController() {
   window_tree_host_manager_->RemoveObserver(this);
 }
 
 bool ScreenPinningController::IsPinned() const {
   return pinned_window_ != nullptr;
 }
 
 void ScreenPinningController::SetPinnedWindow(WmWindow* pinned_window) {
-  window_dimmers_->clear();
+  for (aura::Window* window : windows_with_dimmers_.windows())
+    window->ClearProperty(kWindowDimmerKey);
+  windows_with_dimmers_.RemoveAll();
 
   if (pinned_window->GetWindowState()->IsPinned()) {
     if (pinned_window_) {
       LOG(DFATAL) << "Pinned mode is enabled, while it is already in "
                   << "the pinned mode";
       return;
     }
 
     WmWindow* container = pinned_window->GetParent();
     std::vector<WmWindow*> system_modal_containers =
@@ skipping 85 matching lines @@
       system_modal_container_child_window_observer_.get());
 }
 
 void ScreenPinningController::OnSystemModalContainerWindowStackingChanged(
     WmWindow* window) {
   KeepDimWindowAtBottom(window->GetParent());
 }
 
 WmWindow* ScreenPinningController::CreateWindowDimmer(WmWindow* container) {
   std::unique_ptr<WindowDimmer> window_dimmer =
-      base::MakeUnique<WindowDimmer>(container);
+      base::MakeUnique<WindowDimmer>(container->aura_window());
   window_dimmer->SetDimOpacity(1);  // Fully opaque.
-  window_dimmer->window()->SetFullscreen(true);
+  ::wm::SetWindowFullscreen(window_dimmer->window(), true);
   window_dimmer->window()->Show();
-  WmWindow* window = window_dimmer->window();
-  window_dimmers_->Set(container, std::move(window_dimmer));
+  WmWindow* window = WmWindow::Get(window_dimmer->window());
+  // |container| takes ownership of |window_dimmer|.
+  container->aura_window()->SetProperty(kWindowDimmerKey,
+                                        window_dimmer.release());
+  windows_with_dimmers_.Add(container->aura_window());
   return window;
 }
 
 void ScreenPinningController::OnDisplayConfigurationChanged() {
   // Note: this is called on display attached or detached.
   if (!IsPinned())
     return;
 
   // On display detaching, all necessary windows are transfered to the
   // primary display's tree, and called this.
   // So, delete WindowDimmers which are not a part of target system modal
   // container.
   // On display attaching, the new system modal container does not have the
   // WindowDimmer. So create it.
 
   // First, delete unnecessary WindowDimmers.
-  for (WmWindow* container : window_dimmers_->GetWindows()) {
-    if (container != pinned_window_->GetParent() &&
-        !window_dimmers_->Get(container)->window()->GetTargetVisibility()) {
-      window_dimmers_->Set(container, nullptr);
+  {
+    aura::Window::Windows windows = windows_with_dimmers_.windows();
+    for (aura::Window* container : windows) {
+      if (WmWindow::Get(container) != pinned_window_->GetParent() &&
+          !IsWindowDimmerWindowVisible(container)) {
+        windows_with_dimmers_.Remove(container);
+        container->ClearProperty(kWindowDimmerKey);
+      }
     }
   }
 
   // Then, create missing WindowDimmers.
   std::vector<WmWindow*> system_modal_containers =
       GetSystemModalWindowsExceptPinned(pinned_window_);
   for (WmWindow* system_modal : system_modal_containers) {
-    if (window_dimmers_->Get(system_modal)) {
+    if (system_modal->aura_window()->GetProperty(kWindowDimmerKey)) {
       // |system_modal| already has a WindowDimmer.
       continue;
     }
 
     // This is the new system modal dialog.
     system_modal->StackChildAtBottom(CreateWindowDimmer(system_modal));
 
     // Set observers to the tree.
     WmWindow::GetAuraWindow(system_modal)
         ->AddObserver(system_modal_container_window_observer_.get());
     AddObserverToChildren(system_modal,
                           system_modal_container_child_window_observer_.get());
   }
 }
 
 void ScreenPinningController::KeepPinnedWindowOnTop() {
   if (in_restacking_)
     return;
 
   base::AutoReset<bool> auto_reset(&in_restacking_, true);
   WmWindow* container = pinned_window_->GetParent();
   container->StackChildAtTop(pinned_window_);
-  WindowDimmer* pinned_window_dimmer = window_dimmers_->Get(container);
-  if (pinned_window_dimmer && pinned_window_dimmer->window())
-    container->StackChildBelow(pinned_window_dimmer->window(), pinned_window_);
+  WindowDimmer* pinned_window_dimmer =
+      container->aura_window()->GetProperty(kWindowDimmerKey);
+  if (pinned_window_dimmer && pinned_window_dimmer->window()) {
+    container->StackChildBelow(WmWindow::Get(pinned_window_dimmer->window()),
+                               pinned_window_);
+  }
 }
 
 void ScreenPinningController::KeepDimWindowAtBottom(WmWindow* container) {
   if (in_restacking_)
     return;
 
-  WindowDimmer* window_dimmer = window_dimmers_->Get(container);
+  WindowDimmer* window_dimmer =
+      container->aura_window()->GetProperty(kWindowDimmerKey);
   if (window_dimmer) {
     base::AutoReset<bool> auto_reset(&in_restacking_, true);
-    container->StackChildAtBottom(window_dimmer->window());
+    container->StackChildAtBottom(WmWindow::Get(window_dimmer->window()));
   }
 }
 
 }  // namespace ash