[mus+ash] Removes WmWindow from ash/wm/window_cycle_*

ash/wm/window_cycle_list.cc

 // Copyright 2014 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/window_cycle_list.h"
 
 #include <list>
 #include <map>
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/wm/mru_window_tracker.h"
+#include "ash/wm/window_mirror_view.h"
 #include "ash/wm/window_state.h"
+#include "ash/wm/window_state_aura.h"
+#include "ash/wm/window_util.h"
 #include "ash/wm_window.h"
 #include "base/command_line.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/label.h"
@@ skipping 28 matching lines @@
   }
 
  private:
   std::unique_ptr<views::Painter> painter_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerFillBackgroundPainter);
 };
 
 }  // namespace
 
-// This view represents a single WmWindow by displaying a title and a thumbnail
-// of the window's contents.
+// This view represents a single aura::Window by displaying a title and a
+// thumbnail of the window's contents.
 class WindowPreviewView : public views::View, public aura::WindowObserver {
  public:
-  explicit WindowPreviewView(WmWindow* window)
+  explicit WindowPreviewView(aura::Window* window)
       : window_title_(new views::Label),
         preview_background_(new views::View),
-        mirror_view_(window->CreateViewWithRecreatedLayers().release()),
+        mirror_view_(new wm::WindowMirrorView(window)),
         window_observer_(this) {
-    window_observer_.Add(window->aura_window());
-    window_title_->SetText(window->aura_window()->GetTitle());
+    window_observer_.Add(window);
+    window_title_->SetText(window->GetTitle());
     window_title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     window_title_->SetEnabledColor(SK_ColorWHITE);
     window_title_->SetAutoColorReadabilityEnabled(false);
     // Background is not fully opaque, so subpixel rendering won't look good.
     window_title_->SetSubpixelRenderingEnabled(false);
     // The base font is 12pt (for English) so this comes out to 14pt.
     const int kLabelSizeDelta = 2;
     window_title_->SetFontList(
         window_title_->font_list().DeriveWithSizeDelta(kLabelSizeDelta));
     const int kAboveLabelPadding = 5;
@@ skipping 144 matching lines @@
     const int kBetweenChildPaddingDip = 10;
     views::BoxLayout* layout = new views::BoxLayout(
         views::BoxLayout::kHorizontal, kInsideBorderPaddingDip,
         kInsideBorderPaddingDip, kBetweenChildPaddingDip);
     layout->set_cross_axis_alignment(
         views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
     mirror_container_->SetLayoutManager(layout);
     mirror_container_->SetPaintToLayer();
     mirror_container_->layer()->SetFillsBoundsOpaquely(false);
 
-    for (WmWindow* window : windows) {
+    for (auto* window : windows) {
       // |mirror_container_| owns |view|.
       views::View* view = new WindowPreviewView(window);
       window_view_map_[window] = view;
       mirror_container_->AddChildView(view);
     }
 
     // The background needs to be painted to fill the layer, not the View,
     // because the layer animates bounds changes but the View's bounds change
     // immediately.
     highlight_view_->set_background(new LayerFillBackgroundPainter(
         views::Painter::CreateRoundRectWith1PxBorderPainter(
             SkColorSetA(SK_ColorWHITE, 0x4D), SkColorSetA(SK_ColorWHITE, 0x33),
             kBackgroundCornerRadius)));
     highlight_view_->SetPaintToLayer();
 
     highlight_view_->layer()->SetFillsBoundsOpaquely(false);
 
     AddChildView(highlight_view_);
     AddChildView(mirror_container_);
   }
 
   ~WindowCycleView() override {}
 
-  void SetTargetWindow(WmWindow* target) {
+  void SetTargetWindow(aura::Window* target) {
     target_window_ = target;
     if (GetWidget()) {
       Layout();
       if (target_window_)
         window_view_map_[target_window_]->RequestFocus();
     }
   }
 
-  void HandleWindowDestruction(WmWindow* destroying_window,
-                               WmWindow* new_target) {
+  void HandleWindowDestruction(aura::Window* destroying_window,
+                               aura::Window* new_target) {
     auto view_iter = window_view_map_.find(destroying_window);
     views::View* preview = view_iter->second;
     views::View* parent = preview->parent();
     DCHECK_EQ(mirror_container_, parent);
     window_view_map_.erase(view_iter);
     delete preview;
     // With one of its children now gone, we must re-layout |mirror_container_|.
     // This must happen before SetTargetWindow() to make sure our own Layout()
     // works correctly when it's calculating highlight bounds.
     parent->Layout();
@@ skipping 78 matching lines @@
       flags.setAntiAlias(true);
       corner_radius = kBackgroundCornerRadius;
     }
     canvas->DrawRoundRect(shield_bounds, corner_radius, flags);
   }
 
   View* GetInitiallyFocusedView() override {
     return window_view_map_[target_window_];
   }
 
-  WmWindow* target_window() { return target_window_; }
+  aura::Window* target_window() { return target_window_; }
 
  private:
-  std::map<WmWindow*, views::View*> window_view_map_;
+  std::map<aura::Window*, views::View*> window_view_map_;
   views::View* mirror_container_;
   views::View* highlight_view_;
-  WmWindow* target_window_;
+  aura::Window* target_window_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowCycleView);
 };
 
 WindowCycleList::WindowCycleList(const WindowList& windows)
     : windows_(windows),
       screen_observer_(this) {
   if (!ShouldShowUi())
     Shell::Get()->mru_window_tracker()->SetIgnoreActivations(true);
 
-  for (WmWindow* window : windows_)
-    window->aura_window()->AddObserver(this);
+  for (auto* window : windows_)
+    window->AddObserver(this);
 
   if (ShouldShowUi()) {
     if (g_disable_initial_delay) {
       InitWindowCycleView();
     } else {
       show_ui_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(150),
                            this, &WindowCycleList::InitWindowCycleView);
     }
   }
 }
 
 WindowCycleList::~WindowCycleList() {
   if (!ShouldShowUi())
     Shell::Get()->mru_window_tracker()->SetIgnoreActivations(false);
 
-  for (WmWindow* window : windows_)
-    window->aura_window()->RemoveObserver(this);
+  for (auto* window : windows_)
+    window->RemoveObserver(this);
 
   if (!windows_.empty() && user_did_accept_) {
-    WmWindow* target_window = windows_[current_index_];
+    auto* target_window = windows_[current_index_];
     target_window->Show();
-    target_window->GetWindowState()->Activate();
+    wm::GetWindowState(target_window)->Activate();
   }
 
   if (cycle_ui_widget_)
     cycle_ui_widget_->Close();
 
   // |this| is responsible for notifying |cycle_view_| when windows are
   // destroyed. Since |this| is going away, clobber |cycle_view_|. Otherwise
   // there will be a race where a window closes after now but before the
   // Widget::Close() call above actually destroys |cycle_view_|. See
   // crbug.com/681207
   if (cycle_view_)
     cycle_view_->DestroyContents();
 }
 
 void WindowCycleList::Step(WindowCycleController::Direction direction) {
   if (windows_.empty())
     return;
 
   // When there is only one window, we should give feedback to the user. If the
   // window is minimized, we should also show it.
   if (windows_.size() == 1) {
-    windows_[0]->Animate(::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
+    ::wm::AnimateWindow(windows_[0], ::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
     windows_[0]->Show();
-    windows_[0]->GetWindowState()->Activate();
+    wm::GetWindowState(windows_[0])->Activate();
     return;
   }
 
   DCHECK(static_cast<size_t>(current_index_) < windows_.size());
 
   if (!cycle_view_ && current_index_ == 0) {
     // Special case the situation where we're cycling forward but the MRU window
     // is not active. This occurs when all windows are minimized. The starting
     // window should be the first one rather than the second.
-    if (direction == WindowCycleController::FORWARD && !windows_[0]->IsActive())
+    if (direction == WindowCycleController::FORWARD &&
+        !wm::IsActiveWindow(windows_[0]))
       current_index_ = -1;
   }
 
   // We're in a valid cycle, so step forward or backward.
   current_index_ += direction == WindowCycleController::FORWARD ? 1 : -1;
 
   // Wrap to window list size.
   current_index_ = (current_index_ + windows_.size()) % windows_.size();
   DCHECK(windows_[current_index_]);
 
   if (ShouldShowUi()) {
     if (current_index_ > 1)
       InitWindowCycleView();
 
     if (cycle_view_)
       cycle_view_->SetTargetWindow(windows_[current_index_]);
   }
 }
 
 // static
 void WindowCycleList::DisableInitialDelayForTesting() {
   g_disable_initial_delay = true;
 }
 
 void WindowCycleList::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
 
-  WindowList::iterator i =
-      std::find(windows_.begin(), windows_.end(), WmWindow::Get(window));
+  WindowList::iterator i = std::find(windows_.begin(), windows_.end(), window);
   // TODO(oshima): Change this back to DCHECK once crbug.com/483491 is fixed.
   CHECK(i != windows_.end());
   int removed_index = static_cast<int>(i - windows_.begin());
   windows_.erase(i);
   if (current_index_ > removed_index ||
       current_index_ == static_cast<int>(windows_.size())) {
     current_index_--;
   }
 
   if (cycle_view_) {
-    WmWindow* new_target_window =
+    auto* new_target_window =
         windows_.empty() ? nullptr : windows_[current_index_];
-    cycle_view_->HandleWindowDestruction(WmWindow::Get(window),
-                                         new_target_window);
+    cycle_view_->HandleWindowDestruction(window, new_target_window);
     if (windows_.empty()) {
       // This deletes us.
       Shell::Get()->window_cycle_controller()->CancelCycling();
       return;
     }
   }
 }
 
 void WindowCycleList::OnDisplayAdded(const display::Display& new_display) {}
 
@@ skipping 43 matching lines @@
   widget_rect.set_height(widget_height);
   params.bounds = widget_rect;
   widget->Init(params);
 
   screen_observer_.Add(display::Screen::GetScreen());
   widget->Show();
   cycle_ui_widget_ = widget;
 }
 
 }  // namespace ash