CrOS Alt+Tab UI: no-op when UI is aborted (instead of switching window).

ash/common/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/common/wm/window_cycle_list.h"
 
 #include <list>
 #include <map>
 
 #include "ash/common/wm/mru_window_tracker.h"
@@ skipping 21 matching lines @@
 
 namespace ash {
 
 namespace {
 
 bool g_disable_initial_delay = false;
 
 // Used for the highlight view and the shield (black background).
 constexpr float kBackgroundCornerRadius = 4.f;
 
-// Returns the window immediately below |window| in the current container.
-WmWindow* GetWindowBelow(WmWindow* window) {
-  WmWindow* parent = window->GetParent();
-  if (!parent)
-    return nullptr;
-  const WmWindow::Windows children = parent->GetChildren();
-  auto iter = std::find(children.begin(), children.end(), window);
-  CHECK(*iter == window);
-  return (iter != children.begin()) ? *(iter - 1) : nullptr;
-}
-
 // This background paints a |Painter| but fills the view's layer's size rather
 // than the view's size.
 class LayerFillBackgroundPainter : public views::Background {
  public:
   explicit LayerFillBackgroundPainter(std::unique_ptr<views::Painter> painter)
       : painter_(std::move(painter)) {}
 
   ~LayerFillBackgroundPainter() override {}
 
   void Paint(gfx::Canvas* canvas, views::View* view) const override {
     views::Painter::PaintPainterAt(canvas, painter_.get(),
                                    gfx::Rect(view->layer()->size()));
   }
 
  private:
   std::unique_ptr<views::Painter> painter_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerFillBackgroundPainter);
 };
 
 }  // namespace
 
-// This class restores and moves a window to the front of the stacking order for
-// the duration of the class's scope.
-class ScopedShowWindow : public WmWindowObserver {
- public:
-  ScopedShowWindow();
-  ~ScopedShowWindow() override;
-
-  // Show |window| at the top of the stacking order.
-  void Show(WmWindow* window);
-
-  // Cancel restoring the window on going out of scope.
-  void CancelRestore();
-
- private:
-  // WmWindowObserver:
-  void OnWindowTreeChanging(WmWindow* window,
-                            const TreeChangeParams& params) override;
-
-  // The window being shown.
-  WmWindow* window_;
-
-  // The window immediately below where window_ belongs.
-  WmWindow* stack_window_above_;
-
-  // If true, minimize window_ on going out of scope.
-  bool minimized_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedShowWindow);
-};
-
 // This view represents a single WmWindow by displaying a title and a thumbnail
 // of the window's contents.
 class WindowPreviewView : public views::View, public WmWindowObserver {
  public:
   explicit WindowPreviewView(WmWindow* window)
       : window_title_(new views::Label),
         preview_background_(new views::View),
         mirror_view_(window->CreateViewWithRecreatedLayers().release()),
         window_observer_(this) {
     window_observer_.Add(window);
@@ skipping 270 matching lines @@
       mirror_container_->layer()->SetAnimator(
           ui::LayerAnimator::CreateImplicitAnimator());
       // The selection highlight also animates all bounds changes and never
       // changes other animatable properties.
       highlight_view_->layer()->SetAnimator(
           ui::LayerAnimator::CreateImplicitAnimator());
     }
   }
 
   void OnMouseCaptureLost() override {
-    WmShell::Get()->window_cycle_controller()->StopCycling();
+    WmShell::Get()->window_cycle_controller()->CancelCycling();
   }
 
   void OnPaintBackground(gfx::Canvas* canvas) override {
     // We can't set a bg on the mirror container itself because the highlight
     // view needs to be on top of the bg but behind the target windows.
     const gfx::RectF shield_bounds(mirror_container_->bounds());
     SkPaint paint;
     paint.setColor(SkColorSetA(SK_ColorBLACK, 0xE6));
     paint.setStyle(SkPaint::kFill_Style);
     float corner_radius = 0.f;
@@ skipping 12 matching lines @@
 
  private:
   std::map<WmWindow*, views::View*> window_view_map_;
   views::View* mirror_container_;
   views::View* highlight_view_;
   WmWindow* target_window_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowCycleView);
 };
 
-ScopedShowWindow::ScopedShowWindow()

[varkha, 2017/01/03 22:38:51]

Since you are removing this pre-MD path, maybe update the CL description to
mention it.

[Evan Stade, 2017/01/03 22:41:47]

Done.

-    : window_(nullptr), stack_window_above_(nullptr), minimized_(false) {}
-
-ScopedShowWindow::~ScopedShowWindow() {
-  if (window_) {
-    window_->GetParent()->RemoveObserver(this);
-
-    // Restore window's stacking position.
-    if (stack_window_above_)
-      window_->GetParent()->StackChildAbove(window_, stack_window_above_);
-    else
-      window_->GetParent()->StackChildAtBottom(window_);
-
-    // Restore minimized state.
-    if (minimized_)
-      window_->GetWindowState()->Minimize();
-  }
-}
-
-void ScopedShowWindow::Show(WmWindow* window) {
-  DCHECK(!window_);
-  window_ = window;
-  stack_window_above_ = GetWindowBelow(window);
-  minimized_ = window->GetWindowState()->IsMinimized();
-  window_->GetParent()->AddObserver(this);
-  window_->Show();
-  window_->GetWindowState()->Activate();
-}
-
-void ScopedShowWindow::CancelRestore() {
-  if (!window_)
-    return;
-  window_->GetParent()->RemoveObserver(this);
-  window_ = stack_window_above_ = nullptr;
-}
-
-void ScopedShowWindow::OnWindowTreeChanging(WmWindow* window,
-                                            const TreeChangeParams& params) {
-  // Only interested in removal.
-  if (params.new_parent != nullptr)
-    return;
-
-  if (params.target == window_) {
-    CancelRestore();
-  } else if (params.target == stack_window_above_) {
-    // If the window this window was above is removed, use the next window down
-    // as the restore marker.
-    stack_window_above_ = GetWindowBelow(stack_window_above_);
-  }
-}
-
 WindowCycleList::WindowCycleList(const WindowList& windows)
     : windows_(windows),
-      current_index_(0),
-      cycle_view_(nullptr),
-      cycle_ui_widget_(nullptr),
       screen_observer_(this) {
   if (!ShouldShowUi())
     WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(true);
 
   for (WmWindow* 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())
     WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(false);
 
   for (WmWindow* window : windows_)
     window->RemoveObserver(this);
 
-  if (showing_window_) {
-    showing_window_->CancelRestore();
-  } else if (!windows_.empty()) {
+  if (!windows_.empty() && user_did_accept_) {
     WmWindow* target_window = windows_[current_index_];
     target_window->Show();
     target_window->GetWindowState()->Activate();
   }
 
   if (cycle_ui_widget_)
     cycle_ui_widget_->Close();
 }
 
 void WindowCycleList::Step(WindowCycleController::Direction direction) {
@@ skipping 25 matching lines @@
   // 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_]);
-  } else {
-    // Make sure the next window is visible.
-    showing_window_.reset(new ScopedShowWindow);
-    showing_window_->Show(windows_[current_index_]);
   }
 }
 
 // static
 void WindowCycleList::DisableInitialDelayForTesting() {
   g_disable_initial_delay = true;
 }
 
 void WindowCycleList::OnWindowDestroying(WmWindow* window) {
   window->RemoveObserver(this);
 
   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 =
         windows_.empty() ? nullptr : windows_[current_index_];
     cycle_view_->HandleWindowDestruction(window, new_target_window);
     if (windows_.empty()) {
       // This deletes us.
-      WmShell::Get()->window_cycle_controller()->StopCycling();
+      WmShell::Get()->window_cycle_controller()->CancelCycling();
       return;
     }
   }
 }
 
 void WindowCycleList::OnDisplayAdded(const display::Display& new_display) {}
 
 void WindowCycleList::OnDisplayRemoved(const display::Display& old_display) {}
 
 void WindowCycleList::OnDisplayMetricsChanged(const display::Display& display,
                                               uint32_t changed_metrics) {
   if (cycle_ui_widget_ &&
       display.id() ==
           display::Screen::GetScreen()
               ->GetDisplayNearestWindow(cycle_ui_widget_->GetNativeView())
               .id() &&
       (changed_metrics & (DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_ROTATION))) {
-    WmShell::Get()->window_cycle_controller()->StopCycling();
+    WmShell::Get()->window_cycle_controller()->CancelCycling();
     // |this| is deleted.
     return;
   }
 }
 
 bool WindowCycleList::ShouldShowUi() {
   return windows_.size() > 1;
 }
 
 void WindowCycleList::InitWindowCycleView() {
@@ skipping 23 matching lines @@
   widget->Init(params);
 
   screen_observer_.Add(display::Screen::GetScreen());
   widget->Show();
   widget->SetCapture(cycle_view_);
   widget->set_auto_release_capture(false);
   cycle_ui_widget_ = widget;
 }
 
 }  // namespace ash