Overview optimizations

* Pause occusion tracker during overview animation
* Activate the text filter after animation
* Don't animate backdrop window during overview animation.
* Fix the bounds change issue in WindowGrid. It shouldn't change
the parent window's bounds.

  in both clamshell and tabletmode.
  The web contents should load after animations without backdrop animation.
  No gap at the bottom of the screen after exiting overview mode.

Bug: 898077, 897387
Test: no functional change. Manually tested visual change by entering/exiting overview mode
Change-Id: I60c2709c5394a565bae6d0c4bfdd7006e2e76496
Reviewed-on: https://chromium-review.googlesource.com/c/1304973
Commit-Queue: Mitsuru Oshima <oshima@chromium.org>
Reviewed-by: Sammie Quon <sammiequon@chromium.org>
Cr-Commit-Position: refs/heads/master@{#604206}

ash/wm/overview/overview_utils.cc

@@ -13,6 +13,7 @@
 #include "ash/shell.h"
 #include "ash/wm/overview/cleanup_animation_observer.h"
 #include "ash/wm/overview/scoped_overview_animation_settings.h"
+#include "ash/wm/overview/start_animation_observer.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/splitview/split_view_controller.h"
 #include "ash/wm/window_state.h"
@@ -139,8 +140,14 @@ void FadeInWidgetAndMaybeSlideOnEnter(views::Widget* widget,
   ScopedOverviewAnimationSettings scoped_overview_animation_settings(
       animation_type, window);
   window->layer()->SetOpacity(1.0f);
-  if (slide)
+  if (slide) {
     window->SetTransform(original_transform);
+
+    auto start_observer = std::make_unique<StartAnimationObserver>();
+    scoped_overview_animation_settings.AddObserver(start_observer.get());
+    Shell::Get()->window_selector_controller()->AddStartAnimationObserver(
+        std::move(start_observer));
+  }
 }
 
 void FadeOutWidgetAndMaybeSlideOnExit(std::unique_ptr<views::Widget> widget,

ash/wm/overview/window_grid.cc

@@ -1104,7 +1104,6 @@ void WindowGrid::InitShieldWidget() {
   aura::Window* parent_window = widget_window->parent();
   const gfx::Rect bounds = ash::screen_util::SnapBoundsToDisplayEdge(
       parent_window->bounds(), parent_window);
-  parent_window->SetBounds(bounds);
   widget_window->SetBounds(bounds);
   widget_window->SetName("OverviewModeShield");
 

ash/wm/overview/window_selector.cc

@@ -50,6 +50,7 @@
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/layout/box_layout.h"
+#include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
@@ -104,6 +105,27 @@ struct WindowSelectorItemForRoot {
   const aura::Window* root_window;
 };
 
+// A WidgetDelegate to specify the initialy focused view.
+class TextFilterWidgetDelegate : public views::WidgetDelegate {
+ public:
+  TextFilterWidgetDelegate(views::Widget* widget, views::View* initial_focus)
+      : widget_(widget), initial_focus_(initial_focus) {}
+  ~TextFilterWidgetDelegate() override = default;
+
+  // WidgetDelegate:
+  void DeleteDelegate() override { delete this; }
+  views::Widget* GetWidget() override { return widget_; }
+  const views::Widget* GetWidget() const override { return widget_; }
+  bool ShouldAdvanceFocusToTopLevelWidget() const override { return true; }
+  views::View* GetInitiallyFocusedView() override { return initial_focus_; }
+
+ private:
+  views::Widget* widget_;
+  views::View* initial_focus_;
+
+  DISALLOW_COPY_AND_ASSIGN(TextFilterWidgetDelegate);
+};
+
 // Triggers a shelf visibility update on all root window controllers.
 void UpdateShelfVisibility() {
   for (aura::Window* root : Shell::GetAllRootWindows())
@@ -202,6 +224,9 @@ views::Widget* CreateTextFilter(views::TextfieldController* controller,
   params.name = "OverviewModeTextFilter";
   *text_filter_bottom = params.bounds.bottom() + kTextFieldBottomMargin;
   params.parent = root_window->GetChildById(kShellWindowId_StatusContainer);
+
+  views::Textfield* textfield = new views::Textfield();
+  params.delegate = new TextFilterWidgetDelegate(widget, textfield);
   widget->Init(params);
 
   // Use |container| to specify the padding surrounding the text and to give
@@ -221,7 +246,6 @@ views::Widget* CreateTextFilter(views::TextfieldController* controller,
                   vertical_padding, kTextFilterCornerRadius),
       kTextFilterHorizontalPadding));
 
-  views::Textfield* textfield = new views::Textfield();
   textfield->set_controller(controller);
   textfield->SetBorder(views::NullBorder());
   textfield->SetBackgroundColor(kTextFilterBackgroundColor);
@@ -245,8 +269,6 @@ views::Widget* CreateTextFilter(views::TextfieldController* controller,
   aura::Window* text_filter_widget_window = widget->GetNativeWindow();
   text_filter_widget_window->layer()->SetOpacity(0);
   text_filter_widget_window->SetTransform(transform);
-  widget->Show();
-  textfield->RequestFocus();
 
   return widget;
 }
@@ -747,6 +769,14 @@ void WindowSelector::UpdateMaskAndShadow(bool show) {
   }
 }
 
+void WindowSelector::OnStartingAnimationComplete(bool canceled) {
+  if (!canceled) {
+    UpdateMaskAndShadow(!canceled);
+    if (text_filter_widget_)
+      text_filter_widget_->Show();
+  }
+}
+
 void WindowSelector::OnDisplayRemoved(const display::Display& display) {
   // TODO(flackr): Keep window selection active on remaining displays.
   CancelSelection();

ash/wm/overview/window_selector.h

@@ -217,6 +217,9 @@ class ASH_EXPORT WindowSelector : public display::DisplayObserver,
   // Shows or hides all the window selector items' mask and shadow.
   void UpdateMaskAndShadow(bool show);
 
+  // Called when the overview mode starting animation completes.
+  void OnStartingAnimationComplete(bool canceled);
+
   WindowSelectorDelegate* delegate() { return delegate_; }
 
   SplitViewDragIndicators* split_view_drag_indicators() {

ash/wm/overview/window_selector_controller.cc

@@ -298,6 +298,11 @@ bool WindowSelectorController::ToggleOverview(
       return true;
     }
 
+    // Suspend occlusion tracker until the enter animation is complete.
+    occlusion_tracker_pauser_ =
+        std::make_unique<aura::WindowOcclusionTracker::ScopedPause>(
+            Shell::Get()->aura_env());
+
     window_selector_->set_enter_exit_overview_type(new_type);
     if (type == WindowSelector::EnterExitOverviewType::kWindowsMinimized ||
         type == WindowSelector::EnterExitOverviewType::kSwipeFromShelf) {
@@ -325,23 +330,39 @@ bool WindowSelectorController::ToggleOverview(
     // Clear any animations that may be running from last overview end.
     for (const auto& animation : delayed_animations_)
       animation->Shutdown();
-    if (!delayed_animations_.empty()) {
-      Shell::Get()->NotifyOverviewModeStartingAnimationComplete(
-          /*canceled=*/true);
-    }
+    if (!delayed_animations_.empty())
+      OnStartingAnimationComplete(/*canceled=*/true);
     delayed_animations_.clear();
 
+    // Suspend occlusion tracker until the exit animation is complete.
+    occlusion_tracker_pauser_ =
+        std::make_unique<aura::WindowOcclusionTracker::ScopedPause>(
+            Shell::Get()->aura_env());
+
     window_selector_ = std::make_unique<WindowSelector>(this);
     window_selector_->set_enter_exit_overview_type(new_type);
     Shell::Get()->NotifyOverviewModeStarting();
     window_selector_->Init(windows, hide_windows);
     if (IsBlurAllowed())
       overview_blur_controller_->Blur();
+    if (start_animations_.empty())
+      OnStartingAnimationComplete(/*canceled=*/false);
     OnSelectionStarted();
   }
   return true;
 }
 
+void WindowSelectorController::OnStartingAnimationComplete(bool canceled) {
+  Shell::Get()->NotifyOverviewModeStartingAnimationComplete(canceled);
+  window_selector_->OnStartingAnimationComplete(canceled);
+  occlusion_tracker_pauser_.reset();
+}
+
+void WindowSelectorController::OnEndingAnimationComplete(bool canceled) {
+  Shell::Get()->NotifyOverviewModeEndingAnimationComplete(canceled);
+  occlusion_tracker_pauser_.reset();
+}
+
 bool WindowSelectorController::IsSelecting() const {
   return window_selector_ != nullptr;
 }
@@ -480,15 +501,14 @@ void WindowSelectorController::OnSelectionEnded() {
   if (is_shutting_down_)
     return;
 
-  if (!start_animations_.empty()) {
-    Shell::Get()->NotifyOverviewModeEndingAnimationComplete(
-        /*canceled=*/true);
-  }
+  if (!start_animations_.empty())
+    OnEndingAnimationComplete(/*canceled=*/true);
   start_animations_.clear();
+
+  window_selector_->UpdateMaskAndShadow(/*show=*/false);
   is_shutting_down_ = true;
   Shell::Get()->NotifyOverviewModeEnding();
   auto* window_selector = window_selector_.release();
-  window_selector->UpdateMaskAndShadow(/*show=*/false);
   window_selector->Shutdown();
   // There may be no delayed animations in tests, so unblur right away.
   if (delayed_animations_.empty() && IsBlurAllowed())
@@ -519,7 +539,8 @@ void WindowSelectorController::RemoveAndDestroyAnimationObserver(
   if (!window_selector_ && !previous_empty && delayed_animations_.empty()) {
     if (IsBlurAllowed())
       overview_blur_controller_->Unblur();
-    Shell::Get()->NotifyOverviewModeEndingAnimationComplete(/*canceled=*/false);
+
+    OnEndingAnimationComplete(/*canceled=*/false);
   }
 }
 
@@ -534,11 +555,8 @@ void WindowSelectorController::RemoveAndDestroyStartAnimationObserver(
   const bool previous_empty = start_animations_.empty();
   base::EraseIf(start_animations_, base::MatchesUniquePtr(animation_observer));
 
-  if (!previous_empty && start_animations_.empty()) {
-    Shell::Get()->NotifyOverviewModeStartingAnimationComplete(
-        /*canceled=*/false);
-    window_selector_->UpdateMaskAndShadow(/*show=*/true);
-  }
+  if (!previous_empty && start_animations_.empty())
+    OnStartingAnimationComplete(/*canceled=*/false);
 }
 
 // static

ash/wm/overview/window_selector_controller.h

@@ -13,6 +13,7 @@
 #include "ash/wm/overview/window_selector_delegate.h"
 #include "base/macros.h"
 #include "base/time/time.h"
+#include "ui/aura/window_occlusion_tracker.h"
 
 namespace ash {
 class WindowSelector;
@@ -97,6 +98,9 @@ class ASH_EXPORT WindowSelectorController : public WindowSelectorDelegate {
   // Dispatched when window selection begins.
   void OnSelectionStarted();
 
+  void OnStartingAnimationComplete(bool canceled);
+  void OnEndingAnimationComplete(bool canceled);
+
   // Collection of DelayedAnimationObserver objects that own widgets that may be
   // still animating after overview mode ends. If shell needs to shut down while
   // those animations are in progress, the animations are shut down and the
@@ -106,6 +110,9 @@ class ASH_EXPORT WindowSelectorController : public WindowSelectorDelegate {
   // notify shell that the starting animations have been completed.
   std::vector<std::unique_ptr<DelayedAnimationObserver>> start_animations_;
 
+  std::unique_ptr<aura::WindowOcclusionTracker::ScopedPause>
+      occlusion_tracker_pauser_;
+
   std::unique_ptr<WindowSelector> window_selector_;
   base::Time last_selection_time_;
 

ash/wm/workspace/backdrop_controller.cc

@@ -15,9 +15,11 @@
 #include "ash/public/cpp/app_types.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/public/cpp/window_properties.h"
+#include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/wallpaper/wallpaper_controller.h"
 #include "ash/wm/overview/window_selector_controller.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/backdrop_delegate.h"
 #include "base/auto_reset.h"
@@ -68,7 +70,7 @@ class BackdropEventHandler : public ui::EventHandler {
 }  // namespace
 
 BackdropController::BackdropController(aura::Window* container)
-    : container_(container), in_restacking_(false) {
+    : container_(container) {
   DCHECK(container_);
   Shell::Get()->AddShellObserver(this);
   Shell::Get()->accessibility_controller()->AddObserver(this);
@@ -101,6 +103,10 @@ void BackdropController::OnWindowStackingChanged(aura::Window* window) {
   UpdateBackdrop();
 }
 
+void BackdropController::OnDisplayMetricsChanged() {
+  UpdateBackdrop();
+}
+
 void BackdropController::OnPostWindowStateTypeChange(
     wm::WindowState* window_state,
     mojom::WindowStateType old_type) {
@@ -117,8 +123,8 @@ void BackdropController::UpdateBackdrop() {
   // No need to continue update for recursive calls or in overview mode.
   WindowSelectorController* window_selector_controller =
       Shell::Get()->window_selector_controller();
-  if (in_restacking_ || (window_selector_controller &&
-                         window_selector_controller->IsSelecting())) {
+  if (pause_update_ || (window_selector_controller &&
+                        window_selector_controller->IsSelecting())) {
     return;
   }
 
@@ -129,12 +135,14 @@ void BackdropController::UpdateBackdrop() {
     return;
   }
   // We are changing the order of windows which will cause recursion.
-  base::AutoReset<bool> lock(&in_restacking_, true);
+  base::AutoReset<bool> lock(&pause_update_, true);
   EnsureBackdropWidget();
   UpdateAccessibilityMode();
 
-  if (window == backdrop_window_ && backdrop_->IsVisible())
+  if (window == backdrop_window_ && backdrop_->IsVisible()) {
+    Layout();
     return;
+  }
   if (window->GetRootWindow() != backdrop_window_->GetRootWindow())
     return;
 
@@ -148,11 +156,20 @@ void BackdropController::UpdateBackdrop() {
 }
 
 void BackdropController::OnOverviewModeStarting() {
+  if (backdrop_window_)
+    backdrop_window_->SetProperty(aura::client::kAnimationsDisabledKey, true);
   Hide();
 }
 
-void BackdropController::OnOverviewModeEnded() {
+void BackdropController::OnOverviewModeEnding() {
+  pause_update_ = true;
+}
+
+void BackdropController::OnOverviewModeEndingAnimationComplete(bool canceled) {
+  pause_update_ = false;
   UpdateBackdrop();
+  if (backdrop_window_)
+    backdrop_window_->ClearProperty(aura::client::kAnimationsDisabledKey);
 }
 
 void BackdropController::OnAppListVisibilityChanged(bool shown,
@@ -209,6 +226,8 @@ void BackdropController::EnsureBackdropWidget() {
   ::wm::SetWindowVisibilityAnimationType(
       backdrop_window_, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   backdrop_window_->layer()->SetColor(SK_ColorBLACK);
+
+  wm::GetWindowState(backdrop_window_)->set_allow_set_bounds_direct(true);
 }
 
 void BackdropController::UpdateAccessibilityMode() {
@@ -265,11 +284,7 @@ bool BackdropController::WindowShouldHaveBackdrop(aura::Window* window) {
 }
 
 void BackdropController::Show() {
-  // Makes sure that the backdrop has the correct bounds if it should not be
-  // fullscreen size.
-  backdrop_->SetFullscreen(BackdropShouldFullscreen());
-  if (!BackdropShouldFullscreen())
-    backdrop_->SetBounds(GetBackdropBounds());
+  Layout();
   backdrop_->Show();
 }
 
@@ -315,4 +330,21 @@ gfx::Rect BackdropController::GetBackdropBounds() {
       snapped_window, snap_position);
 }
 
+void BackdropController::Layout() {
+  // Makes sure that the backdrop has the correct bounds if it should not be
+  // fullscreen size.
+  backdrop_->SetFullscreen(BackdropShouldFullscreen());
+  if (backdrop_->IsFullscreen()) {
+    // TODO(oshima): The size of solid color layer can be smaller than texture's
+    // layer with fractional scale (crbug.com/9000220). Use adjusted bounds so
+    // that it can cover texture layer. Fix the bug and remove this.
+    auto* window = backdrop_window_;
+    gfx::Rect bounds = screen_util::GetDisplayBoundsInParent(window);
+    backdrop_window_->SetBounds(
+        screen_util::SnapBoundsToDisplayEdge(bounds, window));
+  } else {
+    backdrop_->SetBounds(GetBackdropBounds());
+  }
+}
+
 }  // namespace ash

ash/wm/workspace/backdrop_controller.h

@@ -57,6 +57,7 @@ class BackdropController : public ShellObserver,
   void OnWindowStackingChanged(aura::Window* window);
   void OnPostWindowStateTypeChange(wm::WindowState* window_state,
                                    mojom::WindowStateType old_type);
+  void OnDisplayMetricsChanged();
 
   void SetBackdropDelegate(std::unique_ptr<BackdropDelegate> delegate);
 
@@ -68,7 +69,8 @@ class BackdropController : public ShellObserver,
 
   // ShellObserver:
   void OnOverviewModeStarting() override;
-  void OnOverviewModeEnded() override;
+  void OnOverviewModeEnding() override;
+  void OnOverviewModeEndingAnimationComplete(bool canceled) override;
   void OnAppListVisibilityChanged(bool shown,
                                   aura::Window* root_window) override;
   void OnSplitViewModeStarting() override;
@@ -92,6 +94,8 @@ class BackdropController : public ShellObserver,
 
   void UpdateAccessibilityMode();
 
+  void Layout();
+
   // Returns the current visible top level window in the container.
   aura::Window* GetTopmostWindowWithBackdrop();
 
@@ -130,8 +134,10 @@ class BackdropController : public ShellObserver,
   std::unique_ptr<ui::EventHandler> backdrop_event_handler_;
   ui::EventHandler* original_event_handler_ = nullptr;
 
-  // If true, the |RestackOrHideWindow| might recurse.
-  bool in_restacking_ = false;
+  // If true, skip updating background. Used to avoid recursive update
+  // when updating the window stack, or delay hiding the backdrop
+  // in overview mode.
+  bool pause_update_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(BackdropController);
 };

ash/wm/workspace/workspace_layout_manager.cc

@@ -387,6 +387,7 @@ void WorkspaceLayoutManager::OnDisplayMetricsChanged(
     const wm::WMEvent event(wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
     AdjustAllWindowsBoundsForWorkAreaChange(&event);
   }
+  backdrop_controller_->OnDisplayMetricsChanged();
 }
 
 //////////////////////////////////////////////////////////////////////////////