Ash Window Cycle UI - add initial show delay and fade in.

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/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 "base/command_line.h"
 #include "ui/accessibility/ax_view_state.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/label.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/views/widget/widget_delegate.h"
 #include "ui/wm/core/visibility_controller.h"
 
@@ skipping 193 matching lines @@
 // A view that shows a collection of windows the user can tab through.
 class WindowCycleView : public views::WidgetDelegateView {
  public:
   explicit WindowCycleView(const WindowCycleList::WindowList& windows)
       : mirror_container_(new views::View()),
         highlight_view_(new views::View()),
         target_window_(nullptr) {
     DCHECK(!windows.empty());
     SetPaintToLayer(true);
     layer()->SetFillsBoundsOpaquely(false);
+    layer()->SetOpacity(0.0);
+    {
+      ui::ScopedLayerAnimationSettings animate_fade(layer()->GetAnimator());
+      animate_fade.SetTransitionDuration(
+          base::TimeDelta::FromMilliseconds(100));

[sky, 2016/08/11 19:36:27]

Please document why this uses a shorter time than is typical.

[Evan Stade, 2016/08/11 20:00:11]

I don't know if there's really a reason beyond "this is what Sebastien thought
felt good". I guess you could go by the old axiom that any action should take at
most 250ms to happen, and with the 150ms initial delay this transition only has
100ms left to work with.

What kind of comment would you like to see for this admittedly arbitrary value?

[sky, 2016/08/11 20:04:44]

Fair enough.

+      layer()->SetOpacity(1.0);
+    }
 
     set_background(views::Background::CreateSolidBackground(
         SkColorSetA(SK_ColorBLACK, 0xCC)));
 
     const int kInsideBorderPaddingDip = 64;
     const int kBetweenChildPaddingDip = 10;
     views::BoxLayout* layout = new views::BoxLayout(
         views::BoxLayout::kHorizontal, kInsideBorderPaddingDip,
         kInsideBorderPaddingDip, kBetweenChildPaddingDip);
     layout->set_cross_axis_alignment(
@@ skipping 23 matching lines @@
             kHighlightCornerRadius))));
     highlight_view_->SetPaintToLayer(true);
     highlight_view_->layer()->SetFillsBoundsOpaquely(false);
     // The selection highlight also animates all bounds changes and never
     // changes other animatable properties.
     highlight_view_->layer()->SetAnimator(
         ui::LayerAnimator::CreateImplicitAnimator());
 
     AddChildView(highlight_view_);
     AddChildView(mirror_container_);
-    SetTargetWindow(windows.front());
   }
 
   ~WindowCycleView() override {}
 
   void SetTargetWindow(WmWindow* target) {
     target_window_ = target;
     if (GetWidget()) {
       Layout();
       DCHECK(Contains(GetFocusManager()->GetFocusedView()));
       window_view_map_[target_window_]->RequestFocus();
     }
   }
 
   void HandleWindowDestruction(WmWindow* destroying_window,
                                WmWindow* new_target) {
     auto view_iter = window_view_map_.find(destroying_window);
     view_iter->second->parent()->RemoveChildView(view_iter->second);
     window_view_map_.erase(view_iter);
     SetTargetWindow(new_target);
   }
 
   // views::WidgetDelegateView overrides:
   gfx::Size GetPreferredSize() const override {
     return mirror_container_->GetPreferredSize();
   }
 
   void Layout() override {
-    // Possible if the last window is deleted.
-    if (!target_window_)
+    if (!target_window_ || bounds().IsEmpty())
       return;
 
     // The preview list (|mirror_container_|) starts flush to the left of
     // the screen but moves to the left (off the edge of the screen) as the use
     // iterates over the previews. The list will move just enough to ensure the
     // highlighted preview is at or to the left of the center of the workspace.
     views::View* target_view = window_view_map_[target_window_];
     gfx::RectF target_bounds(target_view->GetLocalBounds());
     views::View::ConvertRectToTarget(target_view, mirror_container_,
                                      &target_bounds);
@@ skipping 79 matching lines @@
 }
 
 WindowCycleList::WindowCycleList(const WindowList& windows)
     : windows_(windows), current_index_(0), cycle_view_(nullptr) {
   WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(true);
 
   for (WmWindow* window : windows_)
     window->AddObserver(this);
 
   if (ShouldShowUi()) {
-    cycle_view_ = new WindowCycleView(windows_);
-
-    WmWindow* root_window = WmShell::Get()->GetRootWindowForNewWindows();
-    views::Widget* widget = new views::Widget;
-    views::Widget::InitParams params;
-    params.delegate = cycle_view_;
-    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;
-    // TODO(estade): make sure nothing untoward happens when the lock screen
-    // or a system modal dialog is shown.
-    root_window->GetRootWindowController()
-        ->ConfigureWidgetInitParamsForContainer(
-            widget, kShellWindowId_OverlayContainer, &params);
-    widget->Init(params);
-
-    // TODO(estade): right now this just extends past the edge of the screen if
-    // there are too many windows. Handle this more gracefully. Also, if
-    // the display metrics change, cancel the UI.
-    gfx::Rect widget_rect = widget->GetWorkAreaBoundsInScreen();
-    int widget_height = cycle_view_->GetPreferredSize().height();
-    widget_rect.set_y((widget_rect.height() - widget_height) / 2);
-    widget_rect.set_height(widget_height);
-    widget->SetBounds(widget_rect);
-    widget->Show();
-    cycle_ui_widget_.reset(widget);
+    show_ui_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(150),

[sky, 2016/08/11 19:36:27]

Document why the delay.

[Evan Stade, 2016/08/11 20:00:11]

It is documented in the header file above the member declaration, is that
comment insufficient or do you think it should be moved here?

[sky, 2016/08/11 20:04:44]

What you have is fine. I clearly didn't look enough.

+                         this, &WindowCycleList::InitWindowCycleView);
   }
 }
 
 WindowCycleList::~WindowCycleList() {
   WmShell::Get()->mru_window_tracker()->SetIgnoreActivations(false);
   for (WmWindow* window : windows_)
     window->RemoveObserver(this);
 
-  if (showing_window_)
+  if (showing_window_) {
     showing_window_->CancelRestore();
-
-  if (cycle_view_ && cycle_view_->target_window()) {
-    cycle_view_->target_window()->Show();
-    cycle_view_->target_window()->GetWindowState()->Activate();
+  } else if (!windows_.empty()) {
+    WmWindow* target_window = windows_[current_index_];
+    target_window->Show();
+    target_window->GetWindowState()->Activate();
   }
 }
 
 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);
     windows_[0]->Show();
     windows_[0]->GetWindowState()->Activate();
     return;
   }
 
   DCHECK(static_cast<size_t>(current_index_) < windows_.size());
 
   // 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 (cycle_view_) {
-    cycle_view_->SetTargetWindow(windows_[current_index_]);
-    return;
+  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_]);
   }
-
-  // Make sure the next window is visible.
-  showing_window_.reset(new ScopedShowWindow);
-  showing_window_->Show(windows_[current_index_]);
 }
 
 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);
@@ skipping 13 matching lines @@
     }
   }
 }
 
 bool WindowCycleList::ShouldShowUi() {
   return windows_.size() > 1 &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kAshEnableWindowCycleUi);
 }
 
+void WindowCycleList::InitWindowCycleView() {
+  if (cycle_view_)
+    return;
+
+  cycle_view_ = new WindowCycleView(windows_);
+  cycle_view_->SetTargetWindow(windows_[current_index_]);
+
+  WmWindow* root_window = WmShell::Get()->GetRootWindowForNewWindows();
+  views::Widget* widget = new views::Widget;
+  views::Widget::InitParams params;
+  params.delegate = cycle_view_;

[sky, 2016/08/11 19:36:26]

It's very common in ash code to set a name on these widgets to help identify
them later on. I'm suggesting you do something like:

params.name = "WindowCycleList";

This way if you dump the window tree you'll see WindowCycleList.

[Evan Stade, 2016/08/11 20:00:10]

Done.

+  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;
+  // TODO(estade): make sure nothing untoward happens when the lock screen
+  // or a system modal dialog is shown.
+  root_window->GetRootWindowController()->ConfigureWidgetInitParamsForContainer(
+      widget, kShellWindowId_OverlayContainer, &params);
+  widget->Init(params);
+
+  // TODO(estade): right now this just extends past the edge of the screen if
+  // there are too many windows. Handle this more gracefully. Also, if
+  // the display metrics change, cancel the UI.
+  gfx::Rect widget_rect = widget->GetWorkAreaBoundsInScreen();
+  int widget_height = cycle_view_->GetPreferredSize().height();
+  widget_rect.set_y((widget_rect.height() - widget_height) / 2);
+  widget_rect.set_height(widget_height);
+  widget->SetBounds(widget_rect);
+  widget->Show();
+  cycle_ui_widget_.reset(widget);
+}
+
 }  // namespace ash