1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
// 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/frame/custom_frame_view_ash.h"
#include "ash/frame/caption_buttons/frame_caption_button.h"
#include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
#include "ash/shell.h"
#include "ash/test/ash_test_base.h"
#include "ash/test/test_session_state_delegate.h"
#include "ash/wm/maximize_mode/maximize_mode_controller.h"
#include "base/memory/scoped_ptr.h"
#include "grit/ash_resources.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_delegate.h"
namespace ash {
// A views::WidgetDelegate which uses a CustomFrameViewAsh.
class TestWidgetDelegate : public views::WidgetDelegateView {
public:
TestWidgetDelegate() {}
~TestWidgetDelegate() override {}
views::NonClientFrameView* CreateNonClientFrameView(
views::Widget* widget) override {
custom_frame_view_ = new CustomFrameViewAsh(widget);
return custom_frame_view_;
}
CustomFrameViewAsh* custom_frame_view() const {
return custom_frame_view_;
}
private:
// Not owned.
CustomFrameViewAsh* custom_frame_view_;
DISALLOW_COPY_AND_ASSIGN(TestWidgetDelegate);
};
class TestWidgetConstraintsDelegate : public TestWidgetDelegate {
public:
TestWidgetConstraintsDelegate() {}
~TestWidgetConstraintsDelegate() override {}
// views::View:
gfx::Size GetMinimumSize() const override { return minimum_size_; }
gfx::Size GetMaximumSize() const override { return maximum_size_; }
views::View* GetContentsView() override {
// Set this instance as the contents view so that the maximum and minimum
// size constraints will be used.
return this;
}
// views::WidgetDelegate:
bool CanMaximize() const override { return true; }
bool CanMinimize() const override { return true; }
void set_minimum_size(const gfx::Size& min_size) {
minimum_size_ = min_size;
}
void set_maximum_size(const gfx::Size& max_size) {
maximum_size_ = max_size;
}
const gfx::Rect& GetFrameCaptionButtonContainerViewBounds() {
return custom_frame_view()->GetFrameCaptionButtonContainerViewForTest()->
bounds();
}
void EndFrameCaptionButtonContainerViewAnimations() {
FrameCaptionButtonContainerView::TestApi test(custom_frame_view()->
GetFrameCaptionButtonContainerViewForTest());
test.EndAnimations();
}
int GetTitleBarHeight() const {
return custom_frame_view()->NonClientTopBorderHeight();
}
private:
gfx::Size minimum_size_;
gfx::Size maximum_size_;
DISALLOW_COPY_AND_ASSIGN(TestWidgetConstraintsDelegate);
};
class CustomFrameViewAshTest : public test::AshTestBase {
public:
CustomFrameViewAshTest() {}
~CustomFrameViewAshTest() override {}
protected:
scoped_ptr<views::Widget> CreateWidget(TestWidgetDelegate* delegate) {
scoped_ptr<views::Widget> widget(new views::Widget);
views::Widget::InitParams params;
params.delegate = delegate;
params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
params.bounds = gfx::Rect(0, 0, 100, 100);
params.context = CurrentContext();
widget->Init(params);
return widget.Pass();
}
test::TestSessionStateDelegate* GetTestSessionStateDelegate() {
return static_cast<ash::test::TestSessionStateDelegate*>(
Shell::GetInstance()->session_state_delegate());
}
private:
DISALLOW_COPY_AND_ASSIGN(CustomFrameViewAshTest);
};
// Test that the height of the header is correct upon initially displaying
// the widget.
TEST_F(CustomFrameViewAshTest, HeaderHeight) {
TestWidgetDelegate* delegate = new TestWidgetDelegate;
scoped_ptr<views::Widget> widget(CreateWidget(delegate));
widget->Show();
ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
gfx::ImageSkia* close_button =
rb.GetImageSkiaNamed(IDR_AURA_WINDOW_CONTROL_BACKGROUND_H);
// The header should have enough room for the window controls. The
// header/content separator line overlays the window controls.
EXPECT_EQ(close_button->height(),
delegate->custom_frame_view()->GetHeaderView()->height());
}
// Verify that CustomFrameViewAsh returns the correct minimum and maximum frame
// sizes when the client view does not specify any size constraints.
TEST_F(CustomFrameViewAshTest, NoSizeConstraints) {
TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
scoped_ptr<views::Widget> widget(CreateWidget(delegate));
CustomFrameViewAsh* custom_frame_view = delegate->custom_frame_view();
gfx::Size min_frame_size = custom_frame_view->GetMinimumSize();
gfx::Size max_frame_size = custom_frame_view->GetMaximumSize();
EXPECT_EQ(delegate->GetTitleBarHeight(), min_frame_size.height());
// A width and height constraint of 0 denotes unbounded.
EXPECT_EQ(0, max_frame_size.width());
EXPECT_EQ(0, max_frame_size.height());
}
// Verify that CustomFrameViewAsh returns the correct minimum and maximum frame
// sizes when the client view specifies size constraints.
TEST_F(CustomFrameViewAshTest, MinimumAndMaximumSize) {
gfx::Size min_client_size(500, 500);
gfx::Size max_client_size(800, 800);
TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
delegate->set_minimum_size(min_client_size);
delegate->set_maximum_size(max_client_size);
scoped_ptr<views::Widget> widget(CreateWidget(delegate));
CustomFrameViewAsh* custom_frame_view = delegate->custom_frame_view();
gfx::Size min_frame_size = custom_frame_view->GetMinimumSize();
gfx::Size max_frame_size = custom_frame_view->GetMaximumSize();
EXPECT_EQ(min_client_size.width(), min_frame_size.width());
EXPECT_EQ(max_client_size.width(), max_frame_size.width());
EXPECT_EQ(min_client_size.height() + delegate->GetTitleBarHeight(),
min_frame_size.height());
EXPECT_EQ(max_client_size.height() + delegate->GetTitleBarHeight(),
max_frame_size.height());
}
// Verify that CustomFrameViewAsh updates the avatar icon based on the
// state of the SessionStateDelegate after visibility change.
TEST_F(CustomFrameViewAshTest, AvatarIcon) {
TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
scoped_ptr<views::Widget> widget(CreateWidget(delegate));
CustomFrameViewAsh* custom_frame_view = delegate->custom_frame_view();
EXPECT_FALSE(custom_frame_view->GetAvatarIconViewForTest());
// Avatar image becomes available.
const gfx::ImageSkia user_image =
*ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
IDR_AURA_UBER_TRAY_GUEST_ICON);
GetTestSessionStateDelegate()->SetUserImage(user_image);
widget->Hide();
widget->Show();
EXPECT_TRUE(custom_frame_view->GetAvatarIconViewForTest());
// Avatar image is gone; the ImageView for the avatar icon should be
// removed.
GetTestSessionStateDelegate()->SetUserImage(gfx::ImageSkia());
widget->Hide();
widget->Show();
EXPECT_FALSE(custom_frame_view->GetAvatarIconViewForTest());
}
// The visibility of the size button is updated when maximize mode is toggled.
// Verify that the layout of the HeaderView is updated for the size button's
// new visibility.
TEST_F(CustomFrameViewAshTest, HeaderViewNotifiedOfChildSizeChange) {
TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
scoped_ptr<views::Widget> widget(CreateWidget(delegate));
const gfx::Rect initial = delegate->
GetFrameCaptionButtonContainerViewBounds();
Shell::GetInstance()->maximize_mode_controller()->
EnableMaximizeModeWindowManager(true);
delegate->EndFrameCaptionButtonContainerViewAnimations();
const gfx::Rect maximize_mode_bounds = delegate->
GetFrameCaptionButtonContainerViewBounds();
EXPECT_GT(initial.width(), maximize_mode_bounds.width());
Shell::GetInstance()->maximize_mode_controller()->
EnableMaximizeModeWindowManager(false);
delegate->EndFrameCaptionButtonContainerViewAnimations();
const gfx::Rect after_restore = delegate->
GetFrameCaptionButtonContainerViewBounds();
EXPECT_EQ(initial, after_restore);
}
} // namespace ash
|
