blob: e7e80014664a34cdeae70dceffe6a78df0096b24 [file] [log] [blame]
// Copyright 2017 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 "ui/aura/window_occlusion_tracker.h"
#include "base/macros.h"
#include "base/run_loop.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/aura/env.h"
#include "ui/aura/test/aura_test_base.h"
#include "ui/aura/test/env_test_helper.h"
#include "ui/aura/test/test_window_delegate.h"
#include "ui/aura/test/test_windows.h"
#include "ui/aura/window_observer.h"
#include "ui/compositor/layer_animation_sequence.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/compositor/test/layer_animator_test_controller.h"
#include "ui/gfx/interpolated_transform.h"
namespace aura {
namespace {
constexpr base::TimeDelta kTransitionDuration = base::TimeDelta::FromSeconds(3);
enum class WindowOcclusionChangedExpectation {
// Expect OnWindowOcclusionChanged() to be called with true as argument.
OCCLUDED,
// Expect OnWindowOcclusionChanged() to be called with false as argument.
NOT_OCCLUDED,
// Don't expect OnWindowOcclusionChanged() to be called.
NO_CALL,
};
class MockWindowDelegate : public test::ColorTestWindowDelegate {
public:
MockWindowDelegate() : test::ColorTestWindowDelegate(SK_ColorWHITE) {}
~MockWindowDelegate() override { EXPECT_FALSE(is_expecting_call()); }
void set_window(Window* window) { window_ = window; }
void set_expectation(WindowOcclusionChangedExpectation expectation) {
expectation_ = expectation;
}
bool is_expecting_call() const {
return expectation_ != WindowOcclusionChangedExpectation::NO_CALL;
}
void OnWindowOcclusionChanged(bool occluded) override {
ASSERT_TRUE(window_);
if (expectation_ == WindowOcclusionChangedExpectation::OCCLUDED) {
EXPECT_TRUE(occluded);
EXPECT_EQ(Window::OcclusionState::OCCLUDED, window_->occlusion_state());
} else if (expectation_ ==
WindowOcclusionChangedExpectation::NOT_OCCLUDED) {
EXPECT_FALSE(occluded);
EXPECT_EQ(Window::OcclusionState::NOT_OCCLUDED,
window_->occlusion_state());
} else {
ADD_FAILURE() << "Unexpected call to OnWindowOcclusionChanged.";
}
expectation_ = WindowOcclusionChangedExpectation::NO_CALL;
}
private:
WindowOcclusionChangedExpectation expectation_ =
WindowOcclusionChangedExpectation::NO_CALL;
Window* window_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(MockWindowDelegate);
};
class WindowOcclusionTrackerTest : public test::AuraTestBase {
public:
WindowOcclusionTrackerTest() = default;
Window* CreateTrackedWindow(MockWindowDelegate* delegate,
const gfx::Rect& bounds,
Window* parent = nullptr,
bool transparent = false) {
Window* window = new Window(delegate);
delegate->set_window(window);
window->SetType(client::WINDOW_TYPE_NORMAL);
window->Init(ui::LAYER_TEXTURED);
window->SetTransparent(transparent);
window->SetBounds(bounds);
window->Show();
parent = parent ? parent : root_window();
parent->AddChild(window);
WindowOcclusionTracker::Track(window);
return window;
}
Window* CreateUntrackedWindow(const gfx::Rect& bounds,
Window* parent = nullptr) {
Window* window = test::CreateTestWindow(SK_ColorWHITE, 1, bounds,
parent ? parent : root_window());
return window;
}
private:
test::EnvTestHelper env_test_helper_;
DISALLOW_COPY_AND_ASSIGN(WindowOcclusionTrackerTest);
};
} // namespace
// Verify that the non-overlapping windows are notified are not occluded.
// _____ _____
// | | | |
// |____| |____|
TEST_F(WindowOcclusionTrackerTest, NonOverlappingWindows) {
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(15, 0, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
}
// Verify that partially overlapping windows are not occluded.
// ______
// |__| |
// |_____|
TEST_F(WindowOcclusionTrackerTest, PartiallyOverlappingWindow) {
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
}
// Verify that a window whose bounds are covered by a hidden window is not
// occluded. Also, verify that calling Show() on the hidden window causes
// occlusion states to be recomputed.
// __.... ... = hidden window
// |__| .
// .......
TEST_F(WindowOcclusionTrackerTest, HiddenWindowCoversWindow) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b. Expect it to be non-occluded and expect window a to be
// occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 15, 15));
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
// Hide window b. Expect window a to be non-occluded and window b to be
// occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_b->Hide();
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
// Show window b. Expect window a to be occluded and window b to be non-
// occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_b->Show();
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
}
// Verify that a window whose bounds are covered by a semi-transparent window is
// not occluded. Also, verify that that when the opacity of a window changes,
// occlusion states are updated.
// __.... ... = semi-transparent window
// |__| .
// .......
TEST_F(WindowOcclusionTrackerTest, SemiTransparentWindowCoversWindow) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b. Expect it to be non-occluded and expect window a to be
// occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 15, 15));
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
// Change the opacity of window b to 0.5f. Expect both windows to be non-
// occluded.
EXPECT_FALSE(delegate_a->is_expecting_call());
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_b->layer()->SetOpacity(0.5f);
EXPECT_FALSE(delegate_a->is_expecting_call());
// Change the opacity of window b back to 1.0f. Expect window a to be
// occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_b->layer()->SetOpacity(1.0f);
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Same as previous test, but the occlusion state of the semi-transparent is not
// tracked.
TEST_F(WindowOcclusionTrackerTest, SemiTransparentUntrackedWindowCoversWindow) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create untracked window b. Expect window a to be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
Window* window_b = CreateUntrackedWindow(gfx::Rect(0, 0, 15, 15));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Change the opacity of window b to 0.5f. Expect both windows to be non-
// occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_b->layer()->SetOpacity(0.5f);
EXPECT_FALSE(delegate_a->is_expecting_call());
// Change the opacity of window b back to 1.0f. Expect window a to be
// occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_b->layer()->SetOpacity(1.0f);
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that one window whose bounds are covered by a set of two opaque
// windows is occluded.
// ______
// | | | <-- these two windows cover another window
// |__|__|
TEST_F(WindowOcclusionTrackerTest, TwoWindowsOccludeOneWindow) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b with bounds that partially cover window a. Expect both
// windows to be non-occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 5, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
// Create window c with bounds that cover the portion of window a that isn't
// already covered by window b. Expect window a to be occluded and window a/b
// to be non-occluded.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(5, 0, 5, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
}
// Verify that when the bounds of a child window do not cover the bounds of a
// parent window, both windows are non-occluded.
TEST_F(WindowOcclusionTrackerTest, ChildDoesNotOccludeParent) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b with window a as parent. The bounds of window b do not
// fully cover window a. Expect both windows to be non-occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 5, 5), window_a);
EXPECT_FALSE(delegate_b->is_expecting_call());
}
// Verify that when the bounds of a child window cover the bounds of a parent
// window, the parent is occluded and the child is non-occluded. Also, verify
// that when the parent of a window changes, occlusion states are updated.
TEST_F(WindowOcclusionTrackerTest, ChildOccludesParent) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b with window a as parent. The bounds of window b fully cover
// window a. Expect window a to be occluded but not window b.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b =
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 10, 10), window_a);
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
// Create window c whose bounds don't overlap existing windows.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_c = CreateTrackedWindow(delegate_c, gfx::Rect(15, 0, 10, 10));
EXPECT_FALSE(delegate_c->is_expecting_call());
// Change the parent of window b from window a to window c. Expect window a to
// be non-occluded and window c to be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_c->AddChild(window_b);
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
}
// Verify that when the stacking order of windows change, occlusion states are
// updated.
TEST_F(WindowOcclusionTrackerTest, StackingChanged) {
// Create three windows that have the same bounds. Expect window on top of the
// stack to be non-occluded and other windows to be occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
// Move window a on top of the stack. Expect it to be non-occluded and expect
// window c to be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
root_window()->StackChildAtTop(window_a);
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
}
// Verify that when the stacking order of two transparent window changes, the
// occlusion states of their children is updated. The goal of this test is to
// ensure that the fact that the windows whose stacking order change are
// transparent doesn't prevent occlusion states from being recomputed.
TEST_F(WindowOcclusionTrackerTest, TransparentParentStackingChanged) {
// Create window a which is transparent. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10),
root_window(), true);
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which has the same bounds as its parent window a. Expect
// window b to be non-occluded and window a to be occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 10, 10), window_a);
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
// Create window c which is transparent and has the same bounds as window a
// and window b. Expect it to be non-occluded.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_c = CreateTrackedWindow(delegate_c, gfx::Rect(0, 0, 10, 10),
root_window(), true);
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
// Create window d which has the same bounds as its parent window c. Expect
// window d to be non-occluded and all other windows to be occluded.
MockWindowDelegate* delegate_d = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_d->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_d, gfx::Rect(0, 0, 10, 10), window_c);
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
EXPECT_FALSE(delegate_d->is_expecting_call());
// Move window a on top of the stack. Expect its child window b to be non-
// occluded and all other windows to be occluded.
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
delegate_d->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
root_window()->StackChildAtTop(window_a);
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_d->is_expecting_call());
}
// Verify that when StackChildAtTop() is called on a window whose occlusion
// state is not tracked, the occlusion state of tracked siblings is updated.
TEST_F(WindowOcclusionTrackerTest, UntrackedWindowStackingChanged) {
Window* window_a = CreateUntrackedWindow(gfx::Rect(0, 0, 5, 5));
// Create window b. Expect it to be non-occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
// Stack window a on top of window b. Expect window b to be occluded.
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
root_window()->StackChildAtTop(window_a);
EXPECT_FALSE(delegate_b->is_expecting_call());
}
// Verify that occlusion states are updated when the bounds of a window change.
TEST_F(WindowOcclusionTrackerTest, BoundsChanged) {
// Create two non-overlapping windows. Expect them to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
// Move window b on top of window a. Expect window a to be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_b->SetBounds(window_a->bounds());
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that when the bounds of a window are animated, occlusion states are
// updated at the beginning and at the end of the animation, but not during the
// animation. At the beginning of the animation, the window animated window
// should be considered non-occluded and should not occlude other windows. The
// animated window starts occluded.
TEST_F(WindowOcclusionTrackerTest, OccludedWindowBoundsAnimated) {
ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
ui::LayerAnimatorTestController test_controller(
ui::LayerAnimator::CreateImplicitAnimator());
ui::ScopedLayerAnimationSettings layer_animation_settings(
test_controller.animator());
layer_animation_settings.SetTransitionDuration(kTransitionDuration);
// Create 3 windows. Window a is unoccluded. Window c occludes window b.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
window_b->layer()->SetAnimator(test_controller.animator());
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(0, 10, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
// Start animating the bounds of window b so that it moves on top of window a.
// Window b should be non-occluded when the animation starts.
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_b->SetBounds(window_a->bounds());
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Window a should remain non-occluded during the animation.
test_controller.Step(kTransitionDuration / 3);
// Window b should occlude window a at the end of the animation.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_a->is_expecting_call());
window_b->layer()->SetAnimator(nullptr);
}
// Same as the previous test, but the animated window starts non-occluded.
TEST_F(WindowOcclusionTrackerTest, NonOccludedWindowBoundsAnimated) {
ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
ui::LayerAnimatorTestController test_controller(
ui::LayerAnimator::CreateImplicitAnimator());
ui::ScopedLayerAnimationSettings layer_animation_settings(
test_controller.animator());
layer_animation_settings.SetTransitionDuration(kTransitionDuration);
// Create 3 windows. Window a is unoccluded. Window c occludes window b.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_c = CreateTrackedWindow(delegate_c, gfx::Rect(0, 10, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
window_c->layer()->SetAnimator(test_controller.animator());
// Start animating the bounds of window c so that it moves on top of window a.
// Window b should be non-occluded when the animation starts.
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_c->SetBounds(window_a->bounds());
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Window a should remain non-occluded during the animation.
test_controller.Step(kTransitionDuration / 3);
// Window c should occlude window a at the end of the animation.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_a->is_expecting_call());
window_c->layer()->SetAnimator(nullptr);
}
// Verify that occlusion states are updated when the bounds of a transparent
// window with opaque children change.
TEST_F(WindowOcclusionTrackerTest, TransparentParentBoundsChanged) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which doesn't overlap window a and is transparent. Expect
// it to be non-occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 10, 10),
root_window(), true);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Create window c which has window b as parent and doesn't occlude any
// window.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(0, 0, 5, 5), window_b);
EXPECT_FALSE(delegate_c->is_expecting_call());
// Move window b so that window c occludes window a. Expect window a to be
// occluded and other windows to be non-occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_b->SetBounds(gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that occlusion states are updated when the bounds of a window whose
// occlusion state is not tracked change.
TEST_F(WindowOcclusionTrackerTest, UntrackedWindowBoundsChanged) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b. It should not occlude window a.
Window* window_b = CreateUntrackedWindow(gfx::Rect(0, 10, 5, 5));
// Move window b on top of window a. Expect window a to be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_b->SetBounds(window_a->bounds());
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that occlusion states are updated when the transform of a window
// changes.
TEST_F(WindowOcclusionTrackerTest, TransformChanged) {
// Create two non-overlapping windows. Expect them to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
// Scale and translate window b so that it covers window a. Expect window a to
// be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
gfx::Transform transform;
transform.Translate(0.0f, -10.0f);
transform.Scale(2.0f, 2.0f);
window_b->SetTransform(transform);
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that when the transform of a window is animated, occlusion states are
// updated at the beginning and at the end of the animation, but not during the
// animation. At the beginning of the animation, the window animated window
// should be considered non-occluded and should not occlude other windows. The
// animated window starts occluded.
TEST_F(WindowOcclusionTrackerTest, OccludedWindowTransformAnimated) {
ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
ui::LayerAnimatorTestController test_controller(
ui::LayerAnimator::CreateImplicitAnimator());
ui::ScopedLayerAnimationSettings layer_animation_settings(
test_controller.animator());
layer_animation_settings.SetTransitionDuration(kTransitionDuration);
// Create 3 windows. Window a is unoccluded. Window c occludes window b.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
window_b->layer()->SetAnimator(test_controller.animator());
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(0, 10, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
// Start animating the transform of window b so that it moves on top of window
// a. Window b should be non-occluded when the animation starts.
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
auto transform = std::make_unique<ui::InterpolatedScale>(
gfx::Point3F(1, 1, 1), gfx::Point3F(2.0f, 2.0f, 1));
transform->SetChild(std::make_unique<ui::InterpolatedTranslation>(
gfx::PointF(), gfx::PointF(-0.0f, -10.0f)));
test_controller.animator()->StartAnimation(new ui::LayerAnimationSequence(
ui::LayerAnimationElement::CreateInterpolatedTransformElement(
std::move(transform), kTransitionDuration)));
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Window a should remain non-occluded during the animation.
test_controller.Step(kTransitionDuration / 3);
// Window b should occlude window a at the end of the animation.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_a->is_expecting_call());
window_b->layer()->SetAnimator(nullptr);
}
// Same as the previous test, but the animated window starts non-occluded.
TEST_F(WindowOcclusionTrackerTest, NonOccludedWindowTransformAnimated) {
ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
ui::LayerAnimatorTestController test_controller(
ui::LayerAnimator::CreateImplicitAnimator());
ui::ScopedLayerAnimationSettings layer_animation_settings(
test_controller.animator());
layer_animation_settings.SetTransitionDuration(kTransitionDuration);
// Create 3 windows. Window a is unoccluded. Window c occludes window b.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 20, 20));
EXPECT_FALSE(delegate_a->is_expecting_call());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 20, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_c = CreateTrackedWindow(delegate_c, gfx::Rect(0, 20, 10, 10));
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
window_c->layer()->SetAnimator(test_controller.animator());
// Start animating the bounds of window c so that it moves on top of window a.
// Window b should be non-occluded when the animation starts.
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
auto transform = std::make_unique<ui::InterpolatedScale>(
gfx::Point3F(1, 1, 1), gfx::Point3F(2.0f, 2.0f, 1));
transform->SetChild(std::make_unique<ui::InterpolatedTranslation>(
gfx::PointF(), gfx::PointF(-0.0f, -20.0f)));
test_controller.animator()->StartAnimation(new ui::LayerAnimationSequence(
ui::LayerAnimationElement::CreateInterpolatedTransformElement(
std::move(transform), kTransitionDuration)));
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Window a should remain non-occluded during the animation.
test_controller.Step(kTransitionDuration / 3);
// Window c should occlude window a at the end of the animation.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
test_controller.Step(kTransitionDuration / 3);
EXPECT_FALSE(delegate_a->is_expecting_call());
window_c->layer()->SetAnimator(nullptr);
}
// Verify that occlusion states are updated when the transform of a transparent
// window with opaque children change.
TEST_F(WindowOcclusionTrackerTest, TransparentParentTransformChanged) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which doesn't overlap window a and is transparent. Expect
// it to be non-occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 10, 10),
root_window(), true);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Create window c which has window b as parent and doesn't occlude any
// window.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(0, 0, 5, 5), window_b);
EXPECT_FALSE(delegate_c->is_expecting_call());
// Scale and translate window b so that window c occludes window a. Expect
// window a to be occluded and other windows to be non-occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
gfx::Transform transform;
transform.Translate(0.0f, -10.0f);
transform.Scale(2.0f, 2.0f);
window_b->SetTransform(transform);
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that occlusion states are updated when the transform of a window whose
// occlusion state is not tracked changes.
TEST_F(WindowOcclusionTrackerTest, UntrackedWindowTransformChanged) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b. It should not occlude window a.
Window* window_b = CreateUntrackedWindow(gfx::Rect(0, 10, 5, 5));
// Scale and translate window b so that it occludes window a. Expect window a
// to be occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
gfx::Transform transform;
transform.Translate(0.0f, -10.0f);
transform.Scale(2.0f, 2.0f);
window_b->SetTransform(transform);
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that deleting an untracked window which covers a tracked window causes
// the tracked window to be non-occluded.
TEST_F(WindowOcclusionTrackerTest, DeleteUntrackedWindow) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which occludes window a.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
Window* window_b = CreateUntrackedWindow(gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Delete window b. Expect a to be non-occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
delete window_b;
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that removing an untracked window which covers a tracked window causes
// the tracked window to be non-occluded.
TEST_F(WindowOcclusionTrackerTest, RemoveUntrackedWindow) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which occludes window a.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
Window* window_b = CreateUntrackedWindow(gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Delete window b. Expect a to be non-occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
root_window()->RemoveChild(window_b);
EXPECT_FALSE(delegate_a->is_expecting_call());
delete window_b;
}
// Verify that when a tracked window is removed and re-added to a root,
// occlusion states are still tracked.
TEST_F(WindowOcclusionTrackerTest, RemoveAndAddTrackedToRoot) {
Window* window_a = CreateUntrackedWindow(gfx::Rect(0, 0, 1, 1));
CreateUntrackedWindow(gfx::Rect(0, 0, 10, 10), window_a);
// Create window b. Expect it to be non-occluded.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_c = CreateTrackedWindow(delegate_c, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_c->is_expecting_call());
// Remove window c from its root.
root_window()->RemoveChild(window_c);
// Add window c back under its root.
root_window()->AddChild(window_c);
// Create untracked window d which covers window a. Expect window a to be
// occluded.
delegate_c->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
Window* window_d = CreateUntrackedWindow(gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_c->is_expecting_call());
// Move window d so that it doesn't cover window c.
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_d->SetBounds(gfx::Rect(0, 10, 5, 5));
EXPECT_FALSE(delegate_c->is_expecting_call());
// Stack window a on top of window c. Expect window c to be non-occluded. This
// won't work if WindowOcclusionTracked didn't register as an observer of
// window a when window c was made a child of root_window().
delegate_c->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
root_window()->StackChildAtTop(window_a);
EXPECT_FALSE(delegate_c->is_expecting_call());
}
namespace {
class ResizeWindowObserver : public WindowObserver {
public:
ResizeWindowObserver(Window* window_to_resize)
: window_to_resize_(window_to_resize) {}
void OnWindowBoundsChanged(Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds,
ui::PropertyChangeReason reason) override {
window_to_resize_->SetBounds(window->bounds());
}
private:
Window* const window_to_resize_;
DISALLOW_COPY_AND_ASSIGN(ResizeWindowObserver);
;
};
} // namespace
// Verify that when the bounds of a child window are updated in response to the
// bounds of a parent window being updated, occlusion states are updated once.
TEST_F(WindowOcclusionTrackerTest, ResizeChildFromObserver) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b, which is a child of window a. Expect it to be non-
// occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b =
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 5, 5), window_a);
EXPECT_FALSE(delegate_b->is_expecting_call());
// Create an observer that will resize window b when window a is resized.
ResizeWindowObserver resize_window_observer(window_b);
window_a->AddObserver(&resize_window_observer);
// Resize window a. Expect window b to be resized so that window a is
// occluded.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
window_a->SetBounds(gfx::Rect(0, 0, 20, 20));
EXPECT_FALSE(delegate_a->is_expecting_call());
window_a->RemoveObserver(&resize_window_observer);
}
// Verify that the bounds of windows are changed multiple times within the scope
// of a ScopedPauseOcclusionTracking, occlusion states are updated once at the
// end of the scope.
TEST_F(WindowOcclusionTrackerTest, ScopedPauseOcclusionTracking) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which doesn't overlap window a. Expect it to be non-
// occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
// Change bounds multiple times. At the end of the scope, expect window a to
// be occluded.
{
WindowOcclusionTracker::ScopedPauseOcclusionTracking
pause_occlusion_tracking;
window_b->SetBounds(window_a->bounds());
window_a->SetBounds(gfx::Rect(0, 10, 5, 5));
window_b->SetBounds(window_a->bounds());
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
}
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Same as the previous test, but with nested ScopedPauseOcclusionTracking.
TEST_F(WindowOcclusionTrackerTest, NestedScopedPauseOcclusionTracking) {
// Create window a. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b which doesn't overlap window a. Expect it to be non-
// occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 10, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
// Change bounds multiple times. At the end of the scope, expect window a to
// be occluded.
{
WindowOcclusionTracker::ScopedPauseOcclusionTracking
pause_occlusion_tracking_a;
{
WindowOcclusionTracker::ScopedPauseOcclusionTracking
pause_occlusion_tracking_b;
window_b->SetBounds(window_a->bounds());
}
{
WindowOcclusionTracker::ScopedPauseOcclusionTracking
pause_occlusion_tracking_c;
window_a->SetBounds(gfx::Rect(0, 10, 5, 5));
}
{
WindowOcclusionTracker::ScopedPauseOcclusionTracking
pause_occlusion_tracking_d;
window_b->SetBounds(window_a->bounds());
}
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
}
EXPECT_FALSE(delegate_a->is_expecting_call());
}
// Verify that bounds are computed correctly when a hierarchy of windows have
// transforms.
TEST_F(WindowOcclusionTrackerTest, HierarchyOfTransforms) {
gfx::Transform scale_2x_transform;
scale_2x_transform.Scale(2.0f, 2.0f);
// Effective bounds: x = 2, y = 2, height = 10, width = 10
Window* window_a = CreateUntrackedWindow(gfx::Rect(2, 2, 5, 5));
window_a->SetTransform(scale_2x_transform);
// Effective bounds: x = 4, y = 4, height = 4, width = 4
Window* window_b = CreateUntrackedWindow(gfx::Rect(1, 1, 2, 2), window_a);
// Effective bounds: x = 34, y = 36, height = 8, width = 10
CreateUntrackedWindow(gfx::Rect(15, 16, 4, 5), window_b);
MockWindowDelegate* delegate_d = new MockWindowDelegate();
delegate_d->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_d = CreateTrackedWindow(delegate_d, gfx::Rect(34, 36, 8, 10));
EXPECT_FALSE(delegate_d->is_expecting_call());
delegate_d->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
root_window()->StackChildAtBottom(window_d);
EXPECT_FALSE(delegate_d->is_expecting_call());
delegate_d->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_d->SetBounds(gfx::Rect(35, 36, 8, 10));
EXPECT_FALSE(delegate_d->is_expecting_call());
// |window_d| should remain non-occluded with the following bounds changes.
window_d->SetBounds(gfx::Rect(33, 36, 8, 10));
window_d->SetBounds(gfx::Rect(34, 37, 8, 10));
window_d->SetBounds(gfx::Rect(34, 35, 8, 10));
}
// Verify that clipping is taken into account when computing occlusion.
TEST_F(WindowOcclusionTrackerTest, Clipping) {
// Create window b. Expect it to be non-occluded.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_a, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
// Create window b. Expect it to be non-occluded.
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_b = CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 5, 5));
EXPECT_FALSE(delegate_b->is_expecting_call());
window_b->layer()->SetMasksToBounds(true);
// Create window c which has window b as parent. Expect it to occlude window
// b, but not window a since it's clipped.
MockWindowDelegate* delegate_c = new MockWindowDelegate();
delegate_b->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_c->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_c, gfx::Rect(0, 0, 10, 10), window_b);
EXPECT_FALSE(delegate_b->is_expecting_call());
EXPECT_FALSE(delegate_c->is_expecting_call());
}
// Verify that the DCHECK(!WindowIsAnimated(window)) in
// WindowOcclusionTracker::OnWindowDestroyed() doesn't fire if a window is
// destroyed with an incomplete animation (~Window should complete the animation
// and the window should be removed from |animated_windows_| before
// OnWindowDestroyed() is called).
TEST_F(WindowOcclusionTrackerTest, DestroyWindowWithPendingAnimation) {
ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
ui::LayerAnimatorTestController test_controller(
ui::LayerAnimator::CreateImplicitAnimator());
ui::ScopedLayerAnimationSettings layer_animation_settings(
test_controller.animator());
layer_animation_settings.SetTransitionDuration(kTransitionDuration);
MockWindowDelegate* delegate = new MockWindowDelegate();
delegate->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window = CreateTrackedWindow(delegate, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate->is_expecting_call());
window->layer()->SetAnimator(test_controller.animator());
// Start animating the bounds of window.
window->SetBounds(gfx::Rect(10, 10, 5, 5));
test_controller.Step(kTransitionDuration / 3);
EXPECT_TRUE(test_controller.animator()->IsAnimatingProperty(
ui::LayerAnimationElement::BOUNDS));
// Destroy the window. Expect no DCHECK failure.
delete window;
}
// Verify that an animated window stops being considered as animated when its
// layer is recreated.
TEST_F(WindowOcclusionTrackerTest, RecreateLayerOfAnimatedWindow) {
ui::ScopedAnimationDurationScaleMode scoped_animation_duration_scale_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
ui::LayerAnimatorTestController test_controller(
ui::LayerAnimator::CreateImplicitAnimator());
ui::ScopedLayerAnimationSettings layer_animation_settings(
test_controller.animator());
layer_animation_settings.SetTransitionDuration(kTransitionDuration);
// Create 2 windows. Window b occludes window a.
MockWindowDelegate* delegate_a = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
Window* window_a = CreateTrackedWindow(delegate_a, gfx::Rect(2, 2, 1, 1));
EXPECT_FALSE(delegate_a->is_expecting_call());
window_a->layer()->SetAnimator(test_controller.animator());
MockWindowDelegate* delegate_b = new MockWindowDelegate();
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
delegate_b->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
CreateTrackedWindow(delegate_b, gfx::Rect(0, 0, 10, 10));
EXPECT_FALSE(delegate_a->is_expecting_call());
EXPECT_FALSE(delegate_b->is_expecting_call());
// Start animating the bounds of window a. Window a should be non-occluded
// when the animation starts.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::NOT_OCCLUDED);
window_a->SetBounds(gfx::Rect(6, 6, 1, 1));
test_controller.Step(kTransitionDuration / 2);
EXPECT_FALSE(delegate_a->is_expecting_call());
// Recreate the layer of window b. Expect this to behave the same as if the
// animation was abandoned.
delegate_a->set_expectation(WindowOcclusionChangedExpectation::OCCLUDED);
std::unique_ptr<ui::Layer> old_layer = window_a->RecreateLayer();
EXPECT_FALSE(delegate_a->is_expecting_call());
window_a->layer()->SetAnimator(nullptr);
}
} // namespace aura