[mus+ash] Removes WmWindow from ash/wm/mru_window_tracker and overview mode

ash/wm/overview/window_selector_item.cc

 // Copyright 2013 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/overview/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/metrics/user_metrics_action.h"
@@ skipping 22 matching lines @@
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/window/non_client_view.h"
+#include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/shadow.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 
 namespace {
 
 // In the conceptual overview table, the window margin is the space reserved
 // around the window within the cell. This margin does not overlap so the
 // closest distance between adjacent windows will be twice this amount.
@@ skipping 46 matching lines @@
 static const int kExitFadeInMilliseconds = 30;
 
 // Before closing a window animate both the window and the caption to shrink by
 // this fraction of size.
 static const float kPreCloseScale = 0.02f;
 
 // Convenience method to fade in a Window with predefined animation settings.
 // Note: The fade in animation will occur after a delay where the delay is how
 // long the lay out animations take.
 void SetupFadeInAfterLayout(views::Widget* widget) {
-  WmWindow* window = WmWindow::Get(widget->GetNativeWindow());
-  window->SetOpacity(0.0f);
+  aura::Window* window = widget->GetNativeWindow();
+  window->layer()->SetOpacity(0.0f);
   std::unique_ptr<ScopedOverviewAnimationSettings>
       scoped_overview_animation_settings =
           ScopedOverviewAnimationSettingsFactory::Get()
               ->CreateOverviewAnimationSettings(
                   OverviewAnimationType::
                       OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
                   window);
-  window->SetOpacity(1.0f);
+  window->layer()->SetOpacity(1.0f);
 }
 
 // A Button that has a listener and listens to mouse clicks on the visible part
 // of an overview window.
 class ShieldButton : public views::CustomButton {
  public:
   ShieldButton(views::ButtonListener* listener, const base::string16& name)
       : views::CustomButton(listener) {
     SetAccessibleName(name);
   }
@@ skipping 41 matching lines @@
 //   original window's header to semi-transparent color of the overview mode
 //   header (on entry to overview). It is also used on exit from overview to
 //   quickly change the color to a close opaque color in parallel with an
 //   opacity transition to mask the original header reappearing.
 class WindowSelectorItem::RoundedContainerView
     : public views::View,
       public gfx::AnimationDelegate,
       public ui::LayerAnimationObserver {
  public:
   RoundedContainerView(WindowSelectorItem* item,
-                       WmWindow* item_window,
+                       aura::Window* item_window,
                        int corner_radius,
                        SkColor background)
       : item_(item),
         item_window_(item_window),
         corner_radius_(corner_radius),
         initial_color_(background),
         target_color_(background),
         current_value_(0),
         layer_(nullptr),
         animation_(new gfx::SlideAnimation(this)) {
@@ skipping 87 matching lines @@
   const char* GetClassName() const override { return "RoundedContainerView"; }
 
  private:
   // gfx::AnimationDelegate:
   void AnimationEnded(const gfx::Animation* animation) override {
     initial_color_ = target_color_;
     // Tabbed browser windows show the overview mode header behind the window
     // during the initial animation. Once the initial fade-in completes and the
     // overview header is fully exposed update stacking to keep the label above
     // the item which prevents input events from reaching the window.
-    WmWindow* widget_window = WmWindow::Get(GetWidget()->GetNativeWindow());
+    aura::Window* widget_window = GetWidget()->GetNativeWindow();
     if (widget_window && item_window_)
-      widget_window->GetParent()->StackChildAbove(widget_window, item_window_);
+      widget_window->parent()->StackChildAbove(widget_window, item_window_);
     item_window_ = nullptr;
   }
 
   void AnimationProgressed(const gfx::Animation* animation) override {
     current_value_ = animation_->CurrentValueBetween(0, 255);
     SchedulePaint();
   }
 
   void AnimationCanceled(const gfx::Animation* animation) override {
     item_window_ = nullptr;
@@ skipping 17 matching lines @@
     if (0 != (sequence->properties() &
               ui::LayerAnimationElement::AnimatableProperty::OPACITY)) {
       StopObservingLayerAnimations();
     }
   }
 
   void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* sequence) override {}
 
   WindowSelectorItem* item_;
-  WmWindow* item_window_;
+  aura::Window* item_window_;
   int corner_radius_;
   SkColor initial_color_;
   SkColor target_color_;
   int current_value_;
   ui::Layer* layer_;
   std::unique_ptr<gfx::SlideAnimation> animation_;
 
   DISALLOW_COPY_AND_ASSIGN(RoundedContainerView);
 };
 
@@ skipping 55 matching lines @@
 
  private:
   ShieldButton* listener_button_;
   WindowSelectorItem::RoundedContainerView* background_;
   views::Label* label_;
   views::ImageButton* close_button_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptionContainerView);
 };
 
-WindowSelectorItem::WindowSelectorItem(WmWindow* window,
+WindowSelectorItem::WindowSelectorItem(aura::Window* window,
                                        WindowSelector* window_selector)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
       transform_window_(window),
       in_bounds_update_(false),
       selected_(false),
       caption_container_view_(nullptr),
       label_view_(nullptr),
       close_button_(new OverviewCloseButton(this)),
       window_selector_(window_selector),
       background_view_(nullptr) {
-  CreateWindowLabel(window->aura_window()->GetTitle());
-  GetWindow()->aura_window()->AddObserver(this);
+  CreateWindowLabel(window->GetTitle());
+  GetWindow()->AddObserver(this);
 }
 
 WindowSelectorItem::~WindowSelectorItem() {
-  GetWindow()->aura_window()->RemoveObserver(this);
+  GetWindow()->RemoveObserver(this);
 }
 
-WmWindow* WindowSelectorItem::GetWindow() {
+aura::Window* WindowSelectorItem::GetWindow() {
   return transform_window_.window();
 }
 
 void WindowSelectorItem::RestoreWindow() {
   caption_container_view_->listener_button()->ResetListener();
   close_button_->ResetListener();
   transform_window_.RestoreWindow();
   if (background_view_) {
     background_view_->OnItemRestored();
     background_view_ = nullptr;
   }
   UpdateHeaderLayout(
       HeaderFadeInMode::EXIT,
       OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS);
 }
 
 void WindowSelectorItem::EnsureVisible() {
   transform_window_.EnsureVisible();
 }
 
 void WindowSelectorItem::Shutdown() {
   if (transform_window_.GetTopInset()) {
     // Activating a window (even when it is the window that was active before
     // overview) results in stacking it at the top. Maintain the label window
     // stacking position above the item to make the header transformation more
     // gradual upon exiting the overview mode.
-    WmWindow* widget_window = WmWindow::Get(item_widget_->GetNativeWindow());
+    aura::Window* widget_window = item_widget_->GetNativeWindow();
 
     // |widget_window| was originally created in the same container as the
     // |transform_window_| but when closing overview the |transform_window_|
     // could have been reparented if a drag was active. Only change stacking
     // if the windows still belong to the same container.
-    if (widget_window->GetParent() == transform_window_.window()->GetParent()) {
-      widget_window->GetParent()->StackChildAbove(widget_window,
-                                                  transform_window_.window());
+    if (widget_window->parent() == transform_window_.window()->parent()) {
+      widget_window->parent()->StackChildAbove(widget_window,
+                                               transform_window_.window());
     }
   }
   if (background_view_) {
     background_view_->OnItemRestored();
     background_view_ = nullptr;
   }
   FadeOut(std::move(item_widget_));
 }
 
 void WindowSelectorItem::PrepareForOverview() {
   transform_window_.PrepareForOverview();
   UpdateHeaderLayout(HeaderFadeInMode::ENTER,
                      OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
 }
 
-bool WindowSelectorItem::Contains(const WmWindow* target) const {
+bool WindowSelectorItem::Contains(const aura::Window* target) const {
   return transform_window_.Contains(target);
 }
 
 void WindowSelectorItem::SetBounds(const gfx::Rect& target_bounds,
                                    OverviewAnimationType animation_type) {
   if (in_bounds_update_)
     return;
   base::AutoReset<bool> auto_reset_in_bounds_update(&in_bounds_update_, true);
   target_bounds_ = target_bounds;
 
@@ skipping 122 matching lines @@
   params_label.type = views::Widget::InitParams::TYPE_POPUP;
   params_label.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params_label.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params_label.visible_on_all_workspaces = true;
   params_label.layer_type = ui::LAYER_NOT_DRAWN;
   params_label.name = "OverviewModeLabel";
   params_label.activatable =
       views::Widget::InitParams::Activatable::ACTIVATABLE_DEFAULT;
   params_label.accept_events = true;
   item_widget_.reset(new views::Widget);
-  root_window_->GetRootWindowController()
+  RootWindowController::ForWindow(root_window_)
       ->ConfigureWidgetInitParamsForContainer(
-          item_widget_.get(),
-          transform_window_.window()->GetParent()->aura_window()->id(),
+          item_widget_.get(), transform_window_.window()->parent()->id(),
           &params_label);
   item_widget_->set_focus_on_creation(false);
   item_widget_->Init(params_label);
-  WmWindow* widget_window = WmWindow::Get(item_widget_->GetNativeWindow());
+  aura::Window* widget_window = item_widget_->GetNativeWindow();
   if (transform_window_.GetTopInset()) {
     // For windows with headers the overview header fades in above the
     // original window header.
-    widget_window->GetParent()->StackChildAbove(widget_window,
-                                                transform_window_.window());
+    widget_window->parent()->StackChildAbove(widget_window,
+                                             transform_window_.window());
   } else {
     // For tabbed windows the overview header slides from behind. The stacking
     // is then corrected when the animation completes.
-    widget_window->GetParent()->StackChildBelow(widget_window,
-                                                transform_window_.window());
+    widget_window->parent()->StackChildBelow(widget_window,
+                                             transform_window_.window());
   }
   label_view_ = new views::Label(title);
   label_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   label_view_->SetAutoColorReadabilityEnabled(false);
   label_view_->SetEnabledColor(kLabelColor);
   // Tell the label what color it will be drawn onto. It will use whether the
   // background color is opaque or transparent to decide whether to use
   // subpixel rendering. Does not actually set the label's background color.
   label_view_->SetBackgroundColor(kLabelBackgroundColor);
 
   caption_container_view_ = new CaptionContainerView(
       this, label_view_, close_button_, background_view_);
   item_widget_->SetContentsView(caption_container_view_);
   label_view_->SetVisible(false);
   item_widget_->SetOpacity(0);
   item_widget_->Show();
   item_widget_->GetLayer()->SetMasksToBounds(false);
 }
 
 void WindowSelectorItem::UpdateHeaderLayout(
     HeaderFadeInMode mode,
     OverviewAnimationType animation_type) {
-  gfx::Rect transformed_window_bounds = root_window_->ConvertRectFromScreen(
-      transform_window_.GetTransformedBounds());
+  gfx::Rect transformed_window_bounds(transform_window_.GetTransformedBounds());
+  ::wm::ConvertRectFromScreen(root_window_, &transformed_window_bounds);
 
   gfx::Rect label_rect(close_button_->GetPreferredSize());
   label_rect.set_width(transformed_window_bounds.width());
   // For tabbed windows the initial bounds of the caption are set such that it
   // appears to be "growing" up from the window content area.
   label_rect.set_y(
       (mode != HeaderFadeInMode::ENTER || transform_window_.GetTopInset())
           ? -label_rect.height()
           : 0);
   if (background_view_) {
@@ skipping 10 matching lines @@
       // the Shutdown() is called.
       background_view_->AnimateColor(gfx::Tween::EASE_OUT,
                                      kExitFadeInMilliseconds);
       background_view_->set_color(kLabelExitColor);
     }
   }
   if (!label_view_->visible()) {
     label_view_->SetVisible(true);
     SetupFadeInAfterLayout(item_widget_.get());
   }
-  WmWindow* widget_window = WmWindow::Get(item_widget_->GetNativeWindow());
+  aura::Window* widget_window = item_widget_->GetNativeWindow();
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type, widget_window);
   // |widget_window| covers both the transformed window and the header
   // as well as the gap between the windows to prevent events from reaching
   // the window including its sizing borders.
   if (mode != HeaderFadeInMode::ENTER) {
     label_rect.set_height(close_button_->GetPreferredSize().height() +
                           transformed_window_bounds.height());
   }
   label_rect.Inset(-kWindowSelectorMargin, -kWindowSelectorMargin);
   widget_window->SetBounds(label_rect);
   gfx::Transform label_transform;
   label_transform.Translate(transformed_window_bounds.x(),
                             transformed_window_bounds.y());
   widget_window->SetTransform(label_transform);
 }
 
 void WindowSelectorItem::AnimateOpacity(float opacity,
                                         OverviewAnimationType animation_type) {
   DCHECK_GE(opacity, 0.f);
   DCHECK_LE(opacity, 1.f);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   transform_window_.SetOpacity(opacity);
 
   const float header_opacity = selected_ ? 0.f : kHeaderOpacity * opacity;
-  WmWindow* widget_window = WmWindow::Get(item_widget_->GetNativeWindow());
+  aura::Window* widget_window = item_widget_->GetNativeWindow();
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_label =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type, widget_window);
-  widget_window->SetOpacity(header_opacity);
+  widget_window->layer()->SetOpacity(header_opacity);
 }
 
 void WindowSelectorItem::UpdateAccessibilityName() {
   caption_container_view_->listener_button()->SetAccessibleName(
-      GetWindow()->aura_window()->GetTitle());
+      GetWindow()->GetTitle());
 }
 
 void WindowSelectorItem::FadeOut(std::unique_ptr<views::Widget> widget) {
   widget->SetOpacity(1.f);
 
   // Fade out the widget. This animation continues past the lifetime of |this|.
-  WmWindow* widget_window = WmWindow::Get(widget->GetNativeWindow());
+  aura::Window* widget_window = widget->GetNativeWindow();
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(
               OverviewAnimationType::
                   OVERVIEW_ANIMATION_EXIT_OVERVIEW_MODE_FADE_OUT,
               widget_window);
   // CleanupAnimationObserver will delete itself (and the widget) when the
   // opacity animation is complete.
   // Ownership over the observer is passed to the window_selector_->delegate()
   // which has longer lifetime so that animations can continue even after the
   // overview mode is shut down.
   views::Widget* widget_ptr = widget.get();
   std::unique_ptr<CleanupAnimationObserver> observer(
       new CleanupAnimationObserver(std::move(widget)));
   animation_settings->AddObserver(observer.get());
   window_selector_->delegate()->AddDelayedAnimationObserver(
       std::move(observer));
   widget_ptr->SetOpacity(0.f);
 }
 
 gfx::SlideAnimation* WindowSelectorItem::GetBackgroundViewAnimation() {
   return background_view_ ? background_view_->animation() : nullptr;
 }
 
-WmWindow* WindowSelectorItem::GetOverviewWindowForMinimizedStateForTest() {
+aura::Window* WindowSelectorItem::GetOverviewWindowForMinimizedStateForTest() {
   return transform_window_.GetOverviewWindowForMinimizedState();
 }
 
 }  // namespace ash