ash / system / tray / tray_item_view_unittest.cc [blame]

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/system/tray/tray_item_view.h"

#include "ash/system/tray/tray_constants.h"
#include "ash/test/ash_test_base.h"
#include "ash/test/ash_test_util.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/task_environment.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/compositor/test/test_utils.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/controls/image_view.h"
#include "ui/views/widget/widget.h"

namespace ash {

namespace {
constexpr char kShowAnimationSmoothnessHistogramName[] =
    "Ash.StatusArea.TrayItemView.Show";
constexpr char kHideAnimationSmoothnessHistogramName[] =
    "Ash.StatusArea.TrayItemView.Hide";
}  // namespace

// A class that can be used to wait for the given `TrayItemView`'s visibility
// animation to finish (`TrayItemView` does not currently use layer animations,
// so we can't just use `ui::LayerAnimationStoppedWaiter`).
class TrayItemViewAnimationWaiter {
 public:
  explicit TrayItemViewAnimationWaiter(TrayItemView* tray_item)
      : tray_item_(tray_item) {}
  TrayItemViewAnimationWaiter(const TrayItemViewAnimationWaiter&) = delete;
  TrayItemViewAnimationWaiter& operator=(const TrayItemViewAnimationWaiter&) =
      delete;
  ~TrayItemViewAnimationWaiter() = default;

  // Waits for `tray_item_`'s visibility animation to finish, or no-op if it is
  // not currently animating.
  void Wait() {
    if (tray_item_->IsAnimating()) {
      tray_item_->SetAnimationIdleClosureForTest(base::BindOnce(
          &TrayItemViewAnimationWaiter::OnTrayItemAnimationFinished,
          weak_ptr_factory_.GetWeakPtr()));
      run_loop_.Run();
    }
  }

 private:
  // Called when `tray_item_`'s visibility animation finishes.
  void OnTrayItemAnimationFinished() { run_loop_.Quit(); }

  // The tray item whose animation is being waited for. Owned by the views
  // hierarchy.
  raw_ptr<TrayItemView> tray_item_ = nullptr;

  base::RunLoop run_loop_;

  base::WeakPtrFactory<TrayItemViewAnimationWaiter> weak_ptr_factory_{this};
};

class TestTrayItemView : public TrayItemView {
 public:
  explicit TestTrayItemView(Shelf* shelf) : TrayItemView(shelf) {}
  TestTrayItemView(const TestTrayItemView&) = delete;
  TestTrayItemView& operator=(const TestTrayItemView&) = delete;
  ~TestTrayItemView() override = default;

  // TrayItemView:
  void HandleLocaleChange() override {}
};

class TrayItemViewTest : public AshTestBase {
 public:
  TrayItemViewTest()
      : AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
  TrayItemViewTest(const TrayItemViewTest&) = delete;
  TrayItemViewTest& operator=(const TrayItemViewTest&) = delete;
  ~TrayItemViewTest() override = default;

  void SetUp() override {
    AshTestBase::SetUp();

    // Create a hosting widget with non empty bounds so that it actually draws.
    widget_ = CreateFramelessTestWidget();
    widget_->SetBounds(gfx::Rect(0, 0, 100, 80));
    widget_->Show();
    tray_item_ = widget_->SetContentsView(
        std::make_unique<TestTrayItemView>(GetPrimaryShelf()));
    tray_item_->CreateImageView();
    tray_item_->SetVisible(true);

    // Warms up the compositor so that UI changes are picked up in time before
    // throughput tracker is stopped.
    ui::Compositor* const compositor =
        tray_item()->GetWidget()->GetCompositor();
    compositor->ScheduleFullRedraw();
    ASSERT_TRUE(ui::WaitForNextFrameToBePresented(compositor));
  }

  void TearDown() override {
    widget_.reset();
    AshTestBase::TearDown();
  }

  // Helper function that waits not only for `tray_item()`'s animation to finish
  // but also for any animation throughput data to be passed from cc to ui.
  void WaitForAnimation() {
    TrayItemViewAnimationWaiter waiter(tray_item());
    waiter.Wait();

    // Force frames and wait for all throughput trackers to be gone to allow
    // animation throughput data to be passed from cc to ui.
    ui::Compositor* const compositor =
        tray_item()->GetWidget()->GetCompositor();
    while (compositor->has_compositor_metrics_trackers_for_testing()) {
      compositor->ScheduleFullRedraw();
      std::ignore = ui::WaitForNextFrameToBePresented(compositor,
                                                      base::Milliseconds(500));
    }
  }

  // Helper function that waits for `tray_item()` opacity to change to a value
  // different from `opacity`.
  void WaitForAnimationChangeOpacityFrom(float opacity) {
    ASSERT_TRUE(tray_item()->IsAnimating());

    ui::Compositor* const compositor =
        tray_item()->GetWidget()->GetCompositor();
    while (tray_item()->layer()->opacity() == opacity) {
      ASSERT_TRUE(ui::WaitForNextFrameToBePresented(compositor));
    }
  }

  views::Widget* widget() { return widget_.get(); }
  TrayItemView* tray_item() { return tray_item_; }

 protected:
  std::unique_ptr<views::Widget> widget_;

  // Owned by `widget`:
  raw_ptr<TrayItemView, DanglingUntriaged> tray_item_ = nullptr;
};

// Tests that scheduling a `TrayItemView`'s show animation while its hide
// animation is running will stop the hide animation in favor of the show
// animation.
TEST_F(TrayItemViewTest, ShowInterruptsHide) {
  ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
  ASSERT_FALSE(tray_item()->IsAnimating());
  ASSERT_TRUE(tray_item()->GetVisible());

  // Start the tray item's hide animation.
  tray_item()->SetVisible(false);

  // The tray item should be animating to its hide state.
  EXPECT_TRUE(tray_item()->IsAnimating());
  EXPECT_FALSE(tray_item()->target_visible_for_testing());

  // Interrupt the hide animation with the show animation.
  tray_item()->SetVisible(true);

  // The tray item should be animating to its show state.
  EXPECT_TRUE(tray_item()->IsAnimating());
  EXPECT_TRUE(tray_item()->target_visible_for_testing());
}

// Tests that scheduling a `TrayItemView`'s hide animation while its show
// animation is running will stop the show animation in favor of the hide
// animation.
TEST_F(TrayItemViewTest, HideInterruptsShow) {
  // Hide the tray item. Note that at this point in the test animations still
  // complete immediately.
  tray_item()->SetVisible(false);
  ASSERT_FALSE(tray_item()->IsAnimating());
  ASSERT_FALSE(tray_item()->GetVisible());

  // Set the animation duration scale to a non-zero value for the rest of the
  // test.
  ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);

  // Start the tray item's show animation.
  tray_item()->SetVisible(true);

  // The tray item should be animating to its show state.
  EXPECT_TRUE(tray_item()->IsAnimating());
  EXPECT_TRUE(tray_item()->target_visible_for_testing());

  // Interrupt the show animation with the hide animation.
  tray_item()->SetVisible(false);

  // The tray item should be animating to its hide state.
  EXPECT_TRUE(tray_item()->IsAnimating());
  EXPECT_FALSE(tray_item()->target_visible_for_testing());
}

// Regression test for http://b/283494045
TEST_F(TrayItemViewTest, ShowDuringZeroDurationAnimation) {
  ui::ScopedAnimationDurationScaleMode duration_scale1(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);

  // Hide the tray item and wait for animation to complete.
  base::RunLoop run_loop1;
  tray_item()->SetAnimationIdleClosureForTest(run_loop1.QuitClosure());
  tray_item()->SetVisible(false);
  run_loop1.Run();
  ASSERT_FALSE(tray_item()->IsAnimating());
  ASSERT_FALSE(tray_item()->GetVisible());
  ASSERT_EQ(tray_item()->layer()->opacity(), 0.0f);
  {
    // Set animation duration to zero. The screen rotation animation does this,
    // but it's hard to get that animation into the correct state in a test.
    ui::ScopedAnimationDurationScaleMode duration_scale2(
        ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);

    // While animations are zero duration, show the item.
    base::RunLoop run_loop2;
    tray_item()->SetAnimationIdleClosureForTest(run_loop2.QuitClosure());
    tray_item()->SetVisible(true);
    run_loop2.Run();
  }

  // The item should be visible and opaque.
  EXPECT_TRUE(tray_item()->GetVisible());
  EXPECT_EQ(tray_item()->layer()->opacity(), 1.0f);
}

TEST_F(TrayItemViewTest, LargeImageIcon) {
  // Use a size that is larger than the default tray icon size.
  const int kLargeSize = 24;
  static_assert(kLargeSize > kUnifiedTrayIconSize);

  // Set the image to a large image.
  gfx::Size kLargeImageSize(kLargeSize, kLargeSize);
  tray_item()->image_view()->SetImage(
      CreateSolidColorTestImage(kLargeImageSize, SK_ColorRED));

  // The preferred size is the size of the larger image (which is not the
  // default tray icon size, see static_assert above).
  EXPECT_EQ(tray_item()->CalculatePreferredSize({}), kLargeImageSize);
}

// Tests that a smoothness metric is recorded for the "show" animation.
TEST_F(TrayItemViewTest, SmoothnessMetricRecordedForShowAnimation) {
  // Start with the tray item hidden. Note that animations still complete
  // immediately in this part of the test, so no smoothness metrics are emitted.
  tray_item()->SetVisible(false);
  base::HistogramTester histogram_tester;
  histogram_tester.ExpectTotalCount(kHideAnimationSmoothnessHistogramName, 0);

  // Set the animation duration scale to a non-zero value for the rest of the
  // test. Smoothness metrics should be emitted from this point onward.
  ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);

  // Start the tray item's "show" animation and wait for it to finish.
  tray_item()->SetVisible(true);
  WaitForAnimation();

  // Verify that the "show" animation's smoothness metric was recorded.
  histogram_tester.ExpectTotalCount(kShowAnimationSmoothnessHistogramName, 1);
}

// Tests that a smoothness metric is recorded for the "hide" animation.
TEST_F(TrayItemViewTest, SmoothnessMetricRecordedForHideAnimation) {
  base::HistogramTester histogram_tester;
  histogram_tester.ExpectTotalCount(kHideAnimationSmoothnessHistogramName, 0);

  // Set the animation duration scale to a non-zero value for the rest of the
  // test. Smoothness metrics should be emitted from this point onward.
  ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);

  // Start the tray item's "hide" animation and wait for it to finish.
  tray_item()->SetVisible(false);
  WaitForAnimation();

  // Verify that the "hide" animation's smoothness metric was recorded.
  histogram_tester.ExpectTotalCount(kHideAnimationSmoothnessHistogramName, 1);
}

// Tests that the smoothness metric for the "hide" animation is still recorded
// even when the "hide" animation interrupts the "show" animation.
TEST_F(TrayItemViewTest, HideSmoothnessMetricRecordedWhenHideInterruptsShow) {
  // Start with the tray item hidden. Note that animations still complete
  // immediately in this part of the test, so no smoothness metrics are emitted.
  tray_item()->SetVisible(false);
  base::HistogramTester histogram_tester;
  histogram_tester.ExpectTotalCount(kHideAnimationSmoothnessHistogramName, 0);

  // Set the animation duration scale to a non-zero value for the rest of the
  // test. Smoothness metrics should be emitted from this point onward.
  ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);

  // Start the tray item's "show" animation, but interrupt it with the "hide"
  // animation. Wait for the "hide" animation to complete.
  tray_item()->SetVisible(true);

  // Wait for animation to change opacity to actually draw on screen. Otherwise,
  // the interrupted animation may end up as a no-op.
  WaitForAnimationChangeOpacityFrom(0.0f);

  tray_item()->SetVisible(false);
  WaitForAnimation();

  // Verify that the "hide" animation's smoothness metric was recorded.
  histogram_tester.ExpectTotalCount(kHideAnimationSmoothnessHistogramName, 1);
}

// Tests that the smoothness metric for the "show" animation is still recorded
// even when the "show" animation interrupts the "hide" animation.
TEST_F(TrayItemViewTest, ShowSmoothnessMetricRecordedWhenShowInterruptsHide) {
  base::HistogramTester histogram_tester;
  histogram_tester.ExpectTotalCount(kHideAnimationSmoothnessHistogramName, 0);

  // Set the animation duration scale to a non-zero value for the rest of the
  // test. Smoothness metrics should be emitted from this point onward.
  ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
      ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);

  // Start the tray item's "hide" animation, but interrupt it with the "show"
  // animation. Wait for the "show" animation to complete.
  tray_item()->SetVisible(false);

  // Wait for animation to change opacity to actually draw on screen. Otherwise,
  // the interrupted animation may end up as a no-op.
  WaitForAnimationChangeOpacityFrom(1.0f);

  tray_item()->SetVisible(true);
  WaitForAnimation();

  // Verify that the "show" animation's smoothness metric was recorded.
  histogram_tester.ExpectTotalCount(kShowAnimationSmoothnessHistogramName, 1);
}

TEST_F(TrayItemViewTest, IconizedLabelAccessibleProperties) {
  tray_item()->CreateLabel();
  IconizedLabel* label = tray_item()->label();
  ui::AXNodeData data;

  // Test when custom accessible name is empty.
  label->GetViewAccessibility().GetAccessibleNodeData(&data);
  EXPECT_EQ(label->GetTextContext(), views::style::CONTEXT_LABEL);
  EXPECT_EQ(data.role, ax::mojom::Role::kStaticText);
  EXPECT_FALSE(data.HasStringAttribute(ax::mojom::StringAttribute::kName));

  label->SetText(u"Sample text");
  label->SetTextContext(views::style::CONTEXT_DIALOG_TITLE);
  data = ui::AXNodeData();
  label->GetViewAccessibility().GetAccessibleNodeData(&data);
  EXPECT_EQ(data.role, ax::mojom::Role::kTitleBar);
  EXPECT_EQ(data.GetString16Attribute(ax::mojom::StringAttribute::kName),
            u"Sample text");

  // Test when custom accessible name is not empty.
  label->SetCustomAccessibleName(u"Sample name");
  label->SetTextContext(views::style::CONTEXT_LABEL);
  data = ui::AXNodeData();
  label->GetViewAccessibility().GetAccessibleNodeData(&data);
  EXPECT_EQ(data.role, ax::mojom::Role::kStaticText);
  EXPECT_EQ(data.GetString16Attribute(ax::mojom::StringAttribute::kName),
            u"Sample name");

  label->SetTextContext(views::style::CONTEXT_DIALOG_TITLE);
  label->SetText(u"New sample text");
  data = ui::AXNodeData();
  label->GetViewAccessibility().GetAccessibleNodeData(&data);
  EXPECT_EQ(data.role, ax::mojom::Role::kStaticText);
  EXPECT_EQ(data.GetString16Attribute(ax::mojom::StringAttribute::kName),
            u"Sample name");

  // Test when custom accessible name is again set to empty.
  label->SetCustomAccessibleName(u"");
  data = ui::AXNodeData();
  label->GetViewAccessibility().GetAccessibleNodeData(&data);
  EXPECT_EQ(data.role, ax::mojom::Role::kTitleBar);
  EXPECT_EQ(data.GetString16Attribute(ax::mojom::StringAttribute::kName),
            u"New sample text");
}

}  // namespace ash