[CrOS] Initial rough cut of alt-tab window cycling UI.

ash/wm/window_cycle_list.cc

Index: ash/wm/window_cycle_list.cc
diff --git a/ash/wm/window_cycle_list.cc b/ash/wm/window_cycle_list.cc
index 186371eb9ee104e9d66cc62a83a1329d3120bcd6..6d6dac7bd6c8ec4ae490e4e2fb823131786bee3b 100644
--- a/ash/wm/window_cycle_list.cc
+++ b/ash/wm/window_cycle_list.cc
@@ -4,16 +4,43 @@
 
 #include "ash/wm/window_cycle_list.h"
 
+#include <list>
+#include <map>
+
+#include "ash/common/ash_switches.h"
+#include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/forwarding_layer_delegate.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_state.h"
+#include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/shell.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_util.h"
+#include "base/command_line.h"
+#include "ui/compositor/layer_tree_owner.h"
+#include "ui/views/background.h"
+#include "ui/views/layout/box_layout.h"
+#include "ui/views/painter.h"
+#include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
+#include "ui/wm/core/visibility_controller.h"
+#include "ui/wm/core/window_util.h"
 
 namespace ash {
 
+void EnsureAllChildrenAreVisible(ui::Layer* layer) {
+  std::list<ui::Layer*> layers;
+  layers.push_back(layer);
+  while (!layers.empty()) {
+    for (auto child : layers.front()->children())
+      layers.push_back(child);
+    layers.front()->SetVisible(true);
+    layers.pop_front();
+  }
+}
+
 // Returns the window immediately below |window| in the current container.
 WmWindow* GetWindowBelow(WmWindow* window) {
   WmWindow* parent = window->GetParent();
@@ -55,6 +82,171 @@ class ScopedShowWindow : public WmWindowObserver {
   DISALLOW_COPY_AND_ASSIGN(ScopedShowWindow);
 };
 
+// A view that mirrors a single window. Layers are lifted from the underlying
+// window (which gets new ones in their place). New paint calls, if any, are
+// forwarded to the underlying window.
+class WindowMirrorView : public views::View, public ::wm::LayerDelegateFactory {
+ public:
+  explicit WindowMirrorView(WmWindow* window) : target_(window) {
+    DCHECK(window);
+  }
+  ~WindowMirrorView() override {}
+
+  void Init() {
+    SetPaintToLayer(true);
+
+    layer_owner_ = ::wm::RecreateLayers(
+        target_->GetInternalWidget()->GetNativeView(), this);
+
+    GetMirrorLayer()->parent()->Remove(GetMirrorLayer());
+    layer()->Add(GetMirrorLayer());
+
+    // Some extra work is needed when the target window is minimized.
+    if (target_->GetWindowState()->IsMinimized()) {
+      GetMirrorLayer()->SetVisible(true);
+      GetMirrorLayer()->SetOpacity(1);
+      EnsureAllChildrenAreVisible(GetMirrorLayer());

[sadrul, 2016/07/15 14:41:53]

Where do we restore the opacity/visibility?

[Evan Stade, 2016/07/15 17:37:15]

we don't. The mirror layer is owned by |this| (RecreateLayers gives us ownership
of the existing layers, then recreates them for the real window) so once the alt
tab preview is closed, these layers will be disposed.

I'll admit that it's a little bit sketchy that we set all layers to visible, but
it doesn't seem to cause any harm and it's necessary for at least the content
area layer in the minimized window case.

+    }
+  }
+
+  // views::View:
+  gfx::Size GetPreferredSize() const override {
+    const int kMaxWidth = 800;
+    const int kMaxHeight = 600;

[oshima, 2016/07/15 18:28:04]

This looked pretty big. Is this temporary, or I'm misreading something?

[Evan Stade, 2016/07/15 18:44:08]

the visual details like this one are temporary. I suspect sizing logic will get
a little more complicated (e.g. max size could depend on the number of windows.
Too many windows, and the max size gets smaller, eventually we start scrolling
instead of squeezing more previews in.)

+
+    gfx::Size target_size = target_->GetBounds().size();
+    if (target_size.width() <= kMaxWidth &&
+        target_size.height() <= kMaxHeight) {
+      return target_size;
+    }
+
+    float scale =
+        std::min(kMaxWidth / static_cast<float>(target_size.width()),
+                 kMaxHeight / static_cast<float>(target_size.height()));
+    return gfx::ScaleToCeiledSize(target_size, scale, scale);
+  }
+
+  void Layout() override {
+    // Position at 0, 0.
+    GetMirrorLayer()->SetBounds(gfx::Rect(GetMirrorLayer()->bounds().size()));
+
+    // Scale down if necessary.
+    gfx::Transform mirror_transform;
+    if (size() != target_->GetBounds().size()) {
+      const float scale =
+          width() / static_cast<float>(target_->GetBounds().width());
+      mirror_transform.Scale(scale, scale);
+    }
+    GetMirrorLayer()->SetTransform(mirror_transform);
+  }
+
+  // ::wm::LayerDelegateFactory:
+  ui::LayerDelegate* CreateDelegate(ui::LayerDelegate* delegate) override {
+    if (!delegate)
+      return nullptr;
+    delegates_.push_back(
+        base::WrapUnique(new wm::ForwardingLayerDelegate(target_, delegate)));
+
+    return delegates_.back().get();
+  }
+
+ private:
+  // Gets the root of the layer tree that was lifted from |target_| (and is now
+  // a child of |this->layer()|).
+  ui::Layer* GetMirrorLayer() { return layer_owner_->root(); }
+
+  // The original window that is being represented by |this|.
+  WmWindow* target_;
+
+  // Retains ownership of the mirror layer tree.
+  std::unique_ptr<ui::LayerTreeOwner> layer_owner_;
+
+  std::vector<std::unique_ptr<wm::ForwardingLayerDelegate>> delegates_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowMirrorView);
+};
+
+// A view that shows a collection of windows the user can tab through.
+class WindowCycleView : public views::View {
+ public:
+  explicit WindowCycleView(const WindowCycleList::WindowList& windows)
+      : mirror_container_(new views::View()),
+        selector_view_(new views::View()),
+        target_window_(nullptr) {
+    DCHECK(!windows.empty());
+    SetPaintToLayer(true);
+    layer()->SetFillsBoundsOpaquely(false);
+
+    // TODO(estade): adjust constants in this function (colors, spacing, corner
+    // radius) as per mocks.
+    const float kCornerRadius = 5;
+    set_background(views::Background::CreateBackgroundPainter(
+        true, views::Painter::CreateSolidRoundRectPainter(
+                  SkColorSetA(SK_ColorBLACK, 0xA5), kCornerRadius)));
+
+    views::BoxLayout* layout =
+        new views::BoxLayout(views::BoxLayout::kHorizontal, 25, 25, 20);
+    layout->set_cross_axis_alignment(
+        views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
+    mirror_container_->SetLayoutManager(layout);
+
+    for (WmWindow* window : windows) {
+      WindowMirrorView* view = new WindowMirrorView(window);
+      view->Init();
+      window_view_map_[window] = view;
+      mirror_container_->AddChildView(view);
+    }
+
+    selector_view_->set_background(views::Background::CreateBackgroundPainter(
+        true, views::Painter::CreateSolidRoundRectPainter(SK_ColorBLUE,
+                                                          kCornerRadius)));
+
+    AddChildView(selector_view_);
+    AddChildView(mirror_container_);
+    SetTargetWindow(windows.front());
+  }
+
+  ~WindowCycleView() override {}
+
+  void SetTargetWindow(WmWindow* target) {
+    target_window_ = target;
+    if (GetWidget())
+      Layout();
+  }
+
+  void HandleWindowDestruction(WmWindow* destroying_window,
+                               WmWindow* new_target) {
+    views::View* destroying_view = window_view_map_[destroying_window];

[oshima, 2016/07/15 18:28:04]

don't you have to (or want to) erase?

[Evan Stade, 2016/07/15 18:44:08]

technically I don't think it's doing any harm by leaving it there, but sure we
can erase.

+    destroying_view->parent()->RemoveChildView(destroying_view);
+    SetTargetWindow(new_target);
+  }
+
+  // views::View overrides:
+  gfx::Size GetPreferredSize() const override {
+    return mirror_container_->GetPreferredSize();
+  }
+
+  void Layout() override {
+    views::View* target_view = window_view_map_[target_window_];
+    gfx::RectF target_bounds(target_view->GetLocalBounds());
+    views::View::ConvertRectToTarget(target_view, this, &target_bounds);
+    target_bounds.Inset(gfx::InsetsF(-15));
+    selector_view_->SetBoundsRect(gfx::ToEnclosingRect(target_bounds));
+
+    mirror_container_->SetBoundsRect(GetLocalBounds());
+  }
+
+  WmWindow* target_window() { return target_window_; }
+
+ private:
+  std::map<WmWindow*, WindowMirrorView*> window_view_map_;
+  views::View* mirror_container_;
+  views::View* selector_view_;
+  WmWindow* target_window_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowCycleView);
+};
+
 ScopedShowWindow::ScopedShowWindow()
     : window_(nullptr), stack_window_above_(nullptr), minimized_(false) {}
 
@@ -107,11 +299,38 @@ void ScopedShowWindow::OnWindowTreeChanging(WmWindow* window,
 }
 
 WindowCycleList::WindowCycleList(const WindowList& windows)
-    : windows_(windows), current_index_(0) {
+    : windows_(windows), current_index_(0), cycle_view_(nullptr) {
   WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(true);
 
   for (WmWindow* window : windows_)
     window->AddObserver(this);
+
+  if (ShouldShowUi()) {
+    WmWindow* root_window = WmShell::Get()->GetPrimaryRootWindow();
+    views::Widget* widget = new views::Widget;
+    views::Widget::InitParams params;
+    params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
+    params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+    params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+    params.accept_events = true;
+    root_window->GetRootWindowController()
+        ->ConfigureWidgetInitParamsForContainer(
+            widget, kShellWindowId_OverlayContainer, &params);

[oshima, 2016/07/15 19:47:52]

Overlay container is above lock screen and system modal containers,
so you need to make sure hiding them when screen is locked or modal window is
shown.

You can just add TODO for now.

(current approach that relies on containers is a bit problematic, but that's a
separate issue)

[Evan Stade, 2016/07/15 22:49:02]

Done.

+    widget->Init(params);
+
+    cycle_view_ = new WindowCycleView(windows_);
+
+    widget->SetContentsView(cycle_view_);
+    // TODO(estade): right now this just extends past the edge of the screen if
+    // there are too many windows. Handle this more gracefully.
+    gfx::Rect widget_rect = widget->GetWorkAreaBoundsInScreen();
+    gfx::Size widget_size = cycle_view_->GetPreferredSize();
+    widget_rect.ClampToCenteredSize(widget_size);
+    widget_rect.set_width(widget_size.width());
+    widget->SetBounds(widget_rect);

[oshima, 2016/07/15 19:47:52]

you should also handle the case when display metrics changes. Simply canceling
the UI is probably good enough.

Another question is what to do when you have two or more displays.
Are we going to group then per display like over view mode?

[Evan Stade, 2016/07/15 22:49:02]

I don't know what would currently happen with multiple displays and I don't know
what the plan is --- it hasn't been mentioned in the design discussions afaik. I
probably should use GetTargetRootWindow() above instead of PrimaryRootWindow()
(fixed). Do you know how I can manually test this?

+    widget->Show();
+    cycle_ui_widget_.reset(widget);
+  }
 }
 
 WindowCycleList::~WindowCycleList() {
@@ -123,6 +342,11 @@ WindowCycleList::~WindowCycleList() {
   }
   if (showing_window_)
     showing_window_->CancelRestore();
+
+  if (cycle_view_) {
+    cycle_view_->target_window()->Show();
+    cycle_view_->target_window()->GetWindowState()->Activate();
+  }
 }
 
 void WindowCycleList::Step(WindowCycleController::Direction direction) {
@@ -147,6 +371,11 @@ void WindowCycleList::Step(WindowCycleController::Direction direction) {
   current_index_ = (current_index_ + windows_.size()) % windows_.size();
   DCHECK(windows_[current_index_]);
 
+  if (cycle_view_) {
+    cycle_view_->SetTargetWindow(windows_[current_index_]);
+    return;
+  }
+
   // Make sure the next window is visible.
   showing_window_.reset(new ScopedShowWindow);
   showing_window_->Show(windows_[current_index_]);
@@ -164,6 +393,16 @@ void WindowCycleList::OnWindowDestroying(WmWindow* window) {
       current_index_ == static_cast<int>(windows_.size())) {
     current_index_--;

[oshima, 2016/07/15 18:28:04]

what if the 1st window is destroyed?

[Evan Stade, 2016/07/15 18:44:08]

I don't think that would be a problem? If the 1st window is the current window,
current_index_ will not be greater than removed_index. If the 1st window is not
the current window, then we'll correctly decrement current_index to maintain the
same current window.

It would be a problem if there were only one window (see below).

[oshima, 2016/07/15 19:47:52]

Ah yes, that's what I was wondering. If current_index_ == 0, and that's the last
one, then windows_ will be empty and windows_[current_index_] will result in out
of range. Why not
fixing it now?

[Evan Stade, 2016/07/15 22:49:02]

I just thought this was a good stopping point because too much more work and the
patch becomes a bit unwieldy. I thought it would be harder to cancel the UI, but
it seems we can do so pretty easily. Also I wanted to punt on coming up with a
test case but I just went ahead and did it in this patch (here is the test case:
https://jsfiddle.net/evanstade/q4p5mL08/ )

   }
+
+  // TODO(estade): what if this is the last (or second from last) window?
+  if (cycle_view_)
+    cycle_view_->HandleWindowDestruction(window, windows_[current_index_]);
+}
+
+bool WindowCycleList::ShouldShowUi() {
+  return windows_.size() > 1 &&
+         base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kAshEnableWindowCycleUi);
 }
 
 }  // namespace ash