OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/ui/views/tabs/tab.h" | 5 #include "chrome/browser/ui/views/tabs/tab.h" |
6 #include "chrome/browser/ui/views/tabs/tab_controller.h" | 6 #include "chrome/browser/ui/views/tabs/tab_controller.h" |
7 | 7 |
8 #include "base/strings/utf_string_conversions.h" | 8 #include "base/strings/utf_string_conversions.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
10 #include "ui/base/models/list_selection_model.h" | 10 #include "ui/base/models/list_selection_model.h" |
11 #include "ui/views/controls/button/image_button.h" | 11 #include "ui/views/controls/button/image_button.h" |
12 #include "ui/views/test/views_test_base.h" | 12 #include "ui/views/test/views_test_base.h" |
13 #include "ui/views/widget/widget.h" | 13 #include "ui/views/widget/widget.h" |
14 | 14 |
15 using views::Widget; | 15 using views::Widget; |
16 | 16 |
17 class FakeTabController : public TabController { | 17 class FakeTabController : public TabController { |
18 public: | 18 public: |
19 FakeTabController() : immersive_style_(false) { | 19 FakeTabController() : immersive_style_(false), active_tab_(false) { |
20 } | 20 } |
21 virtual ~FakeTabController() {} | 21 virtual ~FakeTabController() {} |
22 | 22 |
23 void set_immersive_style(bool value) { immersive_style_ = value; } | 23 void set_immersive_style(bool value) { immersive_style_ = value; } |
| 24 void set_active_tab(bool value) { active_tab_ = value; } |
24 | 25 |
25 virtual const ui::ListSelectionModel& GetSelectionModel() OVERRIDE { | 26 virtual const ui::ListSelectionModel& GetSelectionModel() OVERRIDE { |
26 return selection_model_; | 27 return selection_model_; |
27 } | 28 } |
28 virtual bool SupportsMultipleSelection() OVERRIDE { return false; } | 29 virtual bool SupportsMultipleSelection() OVERRIDE { return false; } |
29 virtual void SelectTab(Tab* tab) OVERRIDE {} | 30 virtual void SelectTab(Tab* tab) OVERRIDE {} |
30 virtual void ExtendSelectionTo(Tab* tab) OVERRIDE {} | 31 virtual void ExtendSelectionTo(Tab* tab) OVERRIDE {} |
31 virtual void ToggleSelected(Tab* tab) OVERRIDE {} | 32 virtual void ToggleSelected(Tab* tab) OVERRIDE {} |
32 virtual void AddSelectionFromAnchorTo(Tab* tab) OVERRIDE {} | 33 virtual void AddSelectionFromAnchorTo(Tab* tab) OVERRIDE {} |
33 virtual void CloseTab(Tab* tab, CloseTabSource source) OVERRIDE {} | 34 virtual void CloseTab(Tab* tab, CloseTabSource source) OVERRIDE {} |
34 virtual void ShowContextMenuForTab(Tab* tab, | 35 virtual void ShowContextMenuForTab(Tab* tab, |
35 const gfx::Point& p, | 36 const gfx::Point& p, |
36 ui::MenuSourceType source_type) OVERRIDE {} | 37 ui::MenuSourceType source_type) OVERRIDE {} |
37 virtual bool IsActiveTab(const Tab* tab) const OVERRIDE { return false; } | 38 virtual bool IsActiveTab(const Tab* tab) const OVERRIDE { |
| 39 return active_tab_; |
| 40 } |
38 virtual bool IsTabSelected(const Tab* tab) const OVERRIDE { | 41 virtual bool IsTabSelected(const Tab* tab) const OVERRIDE { |
39 return false; | 42 return false; |
40 } | 43 } |
41 virtual bool IsTabPinned(const Tab* tab) const OVERRIDE { return false; } | 44 virtual bool IsTabPinned(const Tab* tab) const OVERRIDE { return false; } |
42 virtual void MaybeStartDrag( | 45 virtual void MaybeStartDrag( |
43 Tab* tab, | 46 Tab* tab, |
44 const ui::LocatedEvent& event, | 47 const ui::LocatedEvent& event, |
45 const ui::ListSelectionModel& original_selection) OVERRIDE {} | 48 const ui::ListSelectionModel& original_selection) OVERRIDE {} |
46 virtual void ContinueDrag(views::View* view, | 49 virtual void ContinueDrag(views::View* view, |
47 const ui::LocatedEvent& event) OVERRIDE {} | 50 const ui::LocatedEvent& event) OVERRIDE {} |
48 virtual bool EndDrag(EndDragReason reason) OVERRIDE { return false; } | 51 virtual bool EndDrag(EndDragReason reason) OVERRIDE { return false; } |
49 virtual Tab* GetTabAt(Tab* tab, | 52 virtual Tab* GetTabAt(Tab* tab, |
50 const gfx::Point& tab_in_tab_coordinates) OVERRIDE { | 53 const gfx::Point& tab_in_tab_coordinates) OVERRIDE { |
51 return NULL; | 54 return NULL; |
52 } | 55 } |
53 virtual void OnMouseEventInTab(views::View* source, | 56 virtual void OnMouseEventInTab(views::View* source, |
54 const ui::MouseEvent& event) OVERRIDE {} | 57 const ui::MouseEvent& event) OVERRIDE {} |
55 virtual bool ShouldPaintTab(const Tab* tab, gfx::Rect* clip) OVERRIDE { | 58 virtual bool ShouldPaintTab(const Tab* tab, gfx::Rect* clip) OVERRIDE { |
56 return true; | 59 return true; |
57 } | 60 } |
58 virtual bool IsImmersiveStyle() const OVERRIDE { return immersive_style_; } | 61 virtual bool IsImmersiveStyle() const OVERRIDE { return immersive_style_; } |
59 | 62 |
60 private: | 63 private: |
61 ui::ListSelectionModel selection_model_; | 64 ui::ListSelectionModel selection_model_; |
62 bool immersive_style_; | 65 bool immersive_style_; |
| 66 bool active_tab_; |
63 | 67 |
64 DISALLOW_COPY_AND_ASSIGN(FakeTabController); | 68 DISALLOW_COPY_AND_ASSIGN(FakeTabController); |
65 }; | 69 }; |
66 | 70 |
67 class TabTest : public views::ViewsTestBase { | 71 class TabTest : public views::ViewsTestBase { |
68 public: | 72 public: |
69 TabTest() {} | 73 TabTest() {} |
70 virtual ~TabTest() {} | 74 virtual ~TabTest() {} |
71 | 75 |
72 static bool IconAnimationInvariant(const Tab& tab) { | 76 static bool IconAnimationInvariant(const Tab& tab) { |
73 bool capture_invariant = | 77 return tab.data().CaptureActive() == (tab.icon_animation_.get() != NULL); |
74 tab.data().CaptureActive() == (tab.icon_animation_.get() != NULL); | 78 } |
75 bool audio_invariant = | 79 |
76 !tab.data().AudioActive() || tab.tab_audio_indicator_->IsAnimating(); | 80 static void CheckForExpectedLayoutAndVisibilityOfElements(const Tab& tab) { |
77 return capture_invariant && audio_invariant; | 81 // Check whether elements are visible when they are supposed to be, given |
| 82 // Tab size and TabRendererData state. |
| 83 if (tab.data_.mini) { |
| 84 if (tab.data_.CaptureActive()) |
| 85 EXPECT_TRUE(tab.ShouldShowIcon()); |
| 86 else |
| 87 EXPECT_TRUE(tab.ShouldShowIcon() != tab.ShouldShowAudioIndicator()); |
| 88 EXPECT_FALSE(tab.ShouldShowCloseBox()); |
| 89 } else if (tab.IsActive()) { |
| 90 EXPECT_TRUE(tab.ShouldShowCloseBox()); |
| 91 switch (tab.IconCapacity()) { |
| 92 case 0: |
| 93 case 1: |
| 94 EXPECT_FALSE(tab.ShouldShowIcon()); |
| 95 EXPECT_FALSE(tab.ShouldShowAudioIndicator()); |
| 96 break; |
| 97 case 2: |
| 98 if (tab.data_.CaptureActive()) |
| 99 EXPECT_TRUE(tab.ShouldShowIcon()); |
| 100 else |
| 101 EXPECT_TRUE(tab.ShouldShowIcon() != tab.ShouldShowAudioIndicator()); |
| 102 break; |
| 103 default: |
| 104 EXPECT_LE(3, tab.IconCapacity()); |
| 105 EXPECT_TRUE(tab.ShouldShowIcon()); |
| 106 if (tab.data_.CaptureActive()) { |
| 107 EXPECT_FALSE(tab.ShouldShowAudioIndicator()); |
| 108 } else { |
| 109 EXPECT_TRUE(tab.data_.AudioActive() == |
| 110 tab.ShouldShowAudioIndicator()); |
| 111 } |
| 112 break; |
| 113 } |
| 114 } else { // Tab not active and not mini tab. |
| 115 switch (tab.IconCapacity()) { |
| 116 case 0: |
| 117 EXPECT_FALSE(tab.ShouldShowCloseBox()); |
| 118 EXPECT_FALSE(tab.ShouldShowIcon()); |
| 119 EXPECT_FALSE(tab.ShouldShowAudioIndicator()); |
| 120 break; |
| 121 case 1: |
| 122 EXPECT_FALSE(tab.ShouldShowCloseBox()); |
| 123 if (tab.data_.CaptureActive()) |
| 124 EXPECT_TRUE(tab.ShouldShowIcon()); |
| 125 else |
| 126 EXPECT_TRUE(tab.ShouldShowIcon() != tab.ShouldShowAudioIndicator()); |
| 127 break; |
| 128 default: |
| 129 EXPECT_LE(2, tab.IconCapacity()); |
| 130 EXPECT_TRUE(tab.ShouldShowIcon()); |
| 131 if (tab.data_.CaptureActive()) { |
| 132 EXPECT_FALSE(tab.ShouldShowAudioIndicator()); |
| 133 } else { |
| 134 EXPECT_TRUE(tab.data_.AudioActive() == |
| 135 tab.ShouldShowAudioIndicator()); |
| 136 } |
| 137 break; |
| 138 } |
| 139 } |
| 140 |
| 141 // Check positioning of elements with respect to each other, and that they |
| 142 // are fully within the contents bounds. |
| 143 const gfx::Rect contents_bounds = tab.GetContentsBounds(); |
| 144 if (tab.ShouldShowIcon()) { |
| 145 EXPECT_LE(contents_bounds.x(), tab.favicon_bounds_.x()); |
| 146 if (tab.title_bounds_.width() > 0) |
| 147 EXPECT_LE(tab.favicon_bounds_.right(), tab.title_bounds_.x()); |
| 148 EXPECT_LE(contents_bounds.y(), tab.favicon_bounds_.y()); |
| 149 EXPECT_LE(tab.favicon_bounds_.bottom(), contents_bounds.bottom()); |
| 150 } |
| 151 if (tab.ShouldShowIcon() && tab.ShouldShowAudioIndicator()) |
| 152 EXPECT_LE(tab.favicon_bounds_.right(), tab.audio_indicator_bounds_.x()); |
| 153 if (tab.ShouldShowAudioIndicator()) { |
| 154 if (tab.title_bounds_.width() > 0) |
| 155 EXPECT_LE(tab.title_bounds_.right(), tab.audio_indicator_bounds_.x()); |
| 156 EXPECT_LE(tab.audio_indicator_bounds_.right(), contents_bounds.right()); |
| 157 EXPECT_LE(contents_bounds.y(), tab.audio_indicator_bounds_.y()); |
| 158 EXPECT_LE(tab.audio_indicator_bounds_.bottom(), contents_bounds.bottom()); |
| 159 } |
| 160 if (tab.ShouldShowAudioIndicator() && tab.ShouldShowCloseBox()) { |
| 161 // Note: The audio indicator can overlap the left-insets of the close box, |
| 162 // but should otherwise be to the left of the close button. |
| 163 EXPECT_LE(tab.audio_indicator_bounds_.right(), |
| 164 tab.close_button_->bounds().x() + |
| 165 tab.close_button_->GetInsets().left()); |
| 166 } |
| 167 if (tab.ShouldShowCloseBox()) { |
| 168 // Note: The title bounds can overlap the left-insets of the close box, |
| 169 // but should otherwise be to the left of the close button. |
| 170 if (tab.title_bounds_.width() > 0) { |
| 171 EXPECT_LE(tab.title_bounds_.right(), |
| 172 tab.close_button_->bounds().x() + |
| 173 tab.close_button_->GetInsets().left()); |
| 174 } |
| 175 EXPECT_LE(tab.close_button_->bounds().right(), contents_bounds.right()); |
| 176 EXPECT_LE(contents_bounds.y(), tab.close_button_->bounds().y()); |
| 177 EXPECT_LE(tab.close_button_->bounds().bottom(), contents_bounds.bottom()); |
| 178 } |
78 } | 179 } |
79 }; | 180 }; |
80 | 181 |
81 TEST_F(TabTest, HitTestTopPixel) { | 182 TEST_F(TabTest, HitTestTopPixel) { |
82 Widget widget; | 183 Widget widget; |
83 Widget::InitParams params(CreateParams(Widget::InitParams::TYPE_WINDOW)); | 184 Widget::InitParams params(CreateParams(Widget::InitParams::TYPE_WINDOW)); |
84 params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; | 185 params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
85 params.bounds.SetRect(10, 20, 300, 400); | 186 params.bounds.SetRect(10, 20, 300, 400); |
86 widget.Init(params); | 187 widget.Init(params); |
87 | 188 |
(...skipping 13 matching lines...) Expand all Loading... |
101 // If the window is maximized, however, we want clicks in the top edge to | 202 // If the window is maximized, however, we want clicks in the top edge to |
102 // select the tab. | 203 // select the tab. |
103 widget.Maximize(); | 204 widget.Maximize(); |
104 EXPECT_TRUE(tab.HitTestPoint(gfx::Point(middle_x, 0))); | 205 EXPECT_TRUE(tab.HitTestPoint(gfx::Point(middle_x, 0))); |
105 | 206 |
106 // But clicks in the area above the slanted sides should still miss. | 207 // But clicks in the area above the slanted sides should still miss. |
107 EXPECT_FALSE(tab.HitTestPoint(gfx::Point(0, 0))); | 208 EXPECT_FALSE(tab.HitTestPoint(gfx::Point(0, 0))); |
108 EXPECT_FALSE(tab.HitTestPoint(gfx::Point(tab.width() - 1, 0))); | 209 EXPECT_FALSE(tab.HitTestPoint(gfx::Point(tab.width() - 1, 0))); |
109 } | 210 } |
110 | 211 |
| 212 TEST_F(TabTest, LayoutAndVisibilityOfElements) { |
| 213 FakeTabController controller; |
| 214 Tab tab(&controller); |
| 215 |
| 216 SkBitmap bitmap; |
| 217 bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16); |
| 218 bitmap.allocPixels(); |
| 219 TabRendererData data; |
| 220 data.favicon = gfx::ImageSkia::CreateFrom1xBitmap(bitmap); |
| 221 |
| 222 // Perform layout over all possible combinations, checking for correct |
| 223 // results. |
| 224 for (int is_mini_tab = 0; is_mini_tab < 2; ++is_mini_tab) { |
| 225 for (int is_active_tab = 0; is_active_tab < 2; ++is_active_tab) { |
| 226 for (int audio_state = TabRendererData::AUDIO_STATE_NONE; |
| 227 audio_state <= TabRendererData::AUDIO_STATE_PLAYING; ++audio_state) { |
| 228 for (int capture_state = TabRendererData::CAPTURE_STATE_NONE; |
| 229 capture_state <= TabRendererData::CAPTURE_STATE_PROJECTING; |
| 230 ++capture_state) { |
| 231 SCOPED_TRACE(::testing::Message() |
| 232 << (is_active_tab ? "Active" : "Inactive") << ' ' |
| 233 << (is_mini_tab ? "Mini " : "") |
| 234 << "Tab with audio_state=" << audio_state |
| 235 << " and capture_state=" << capture_state); |
| 236 data.mini = !!is_mini_tab; |
| 237 controller.set_active_tab(!!is_active_tab); |
| 238 data.audio_state = |
| 239 static_cast<TabRendererData::AudioState>(audio_state); |
| 240 data.capture_state = |
| 241 static_cast<TabRendererData::CaptureState>(capture_state); |
| 242 tab.SetData(data); |
| 243 |
| 244 // Test layout for every width from standard to minimum. |
| 245 gfx::Rect bounds(gfx::Point(0, 0), Tab::GetStandardSize()); |
| 246 int min_width; |
| 247 if (is_mini_tab) { |
| 248 bounds.set_width(Tab::GetMiniWidth()); |
| 249 min_width = Tab::GetMiniWidth(); |
| 250 } else { |
| 251 min_width = is_active_tab ? Tab::GetMinimumSelectedSize().width() : |
| 252 Tab::GetMinimumUnselectedSize().width(); |
| 253 } |
| 254 while (bounds.width() >= min_width) { |
| 255 SCOPED_TRACE(::testing::Message() |
| 256 << "bounds=" << bounds.ToString()); |
| 257 tab.SetBoundsRect(bounds); // Invokes Tab::Layout(). |
| 258 CheckForExpectedLayoutAndVisibilityOfElements(tab); |
| 259 bounds.set_width(bounds.width() - 1); |
| 260 } |
| 261 } |
| 262 } |
| 263 } |
| 264 } |
| 265 } |
| 266 |
111 // Regression test for http://crbug.com/226253. Calling Layout() more than once | 267 // Regression test for http://crbug.com/226253. Calling Layout() more than once |
112 // shouldn't change the insets of the close button. | 268 // shouldn't change the insets of the close button. |
113 TEST_F(TabTest, CloseButtonLayout) { | 269 TEST_F(TabTest, CloseButtonLayout) { |
114 FakeTabController tab_controller; | 270 FakeTabController tab_controller; |
115 Tab tab(&tab_controller); | 271 Tab tab(&tab_controller); |
116 tab.SetBounds(0, 0, 100, 50); | 272 tab.SetBounds(0, 0, 100, 50); |
117 tab.Layout(); | 273 tab.Layout(); |
118 gfx::Insets close_button_insets = tab.close_button_->GetInsets(); | 274 gfx::Insets close_button_insets = tab.close_button_->GetInsets(); |
119 tab.Layout(); | 275 tab.Layout(); |
120 gfx::Insets close_button_insets_2 = tab.close_button_->GetInsets(); | 276 gfx::Insets close_button_insets_2 = tab.close_button_->GetInsets(); |
121 EXPECT_EQ(close_button_insets.top(), close_button_insets_2.top()); | 277 EXPECT_EQ(close_button_insets.top(), close_button_insets_2.top()); |
122 EXPECT_EQ(close_button_insets.left(), close_button_insets_2.left()); | 278 EXPECT_EQ(close_button_insets.left(), close_button_insets_2.left()); |
123 EXPECT_EQ(close_button_insets.bottom(), close_button_insets_2.bottom()); | 279 EXPECT_EQ(close_button_insets.bottom(), close_button_insets_2.bottom()); |
124 EXPECT_EQ(close_button_insets.right(), close_button_insets_2.right()); | 280 EXPECT_EQ(close_button_insets.right(), close_button_insets_2.right()); |
125 | 281 |
126 // Also make sure the close button is sized as large as the tab. | 282 // Also make sure the close button is sized as large as the tab. |
127 EXPECT_EQ(50, tab.close_button_->bounds().height()); | 283 EXPECT_EQ(50, tab.close_button_->bounds().height()); |
128 } | 284 } |
129 | 285 |
130 TEST_F(TabTest, ActivityIndicators) { | 286 TEST_F(TabTest, RecordingAndProjectingActivityIndicators) { |
131 FakeTabController controller; | 287 FakeTabController controller; |
132 Tab tab(&controller); | 288 Tab tab(&controller); |
| 289 tab.SetBoundsRect(gfx::Rect(gfx::Point(0, 0), Tab::GetStandardSize())); |
133 | 290 |
134 SkBitmap bitmap; | 291 SkBitmap bitmap; |
135 bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16); | 292 bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16); |
136 bitmap.allocPixels(); | 293 bitmap.allocPixels(); |
137 | 294 |
138 TabRendererData data; | 295 TabRendererData data; |
139 data.favicon = gfx::ImageSkia::CreateFrom1xBitmap(bitmap); | 296 data.favicon = gfx::ImageSkia::CreateFrom1xBitmap(bitmap); |
140 tab.SetData(data); | 297 tab.SetData(data); |
141 | 298 |
142 // Audio starts and stops. | 299 // Recording starts and stops. |
143 data.audio_state = TabRendererData::AUDIO_STATE_PLAYING; | |
144 tab.SetData(data); | |
145 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
146 EXPECT_EQ(TabRendererData::AUDIO_STATE_PLAYING, tab.data().audio_state); | |
147 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); | |
148 data.audio_state = TabRendererData::AUDIO_STATE_NONE; | |
149 tab.SetData(data); | |
150 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
151 EXPECT_EQ(TabRendererData::AUDIO_STATE_NONE, tab.data().audio_state); | |
152 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); | |
153 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
154 | |
155 // Capture starts and stops. | |
156 data.capture_state = TabRendererData::CAPTURE_STATE_RECORDING; | 300 data.capture_state = TabRendererData::CAPTURE_STATE_RECORDING; |
157 tab.SetData(data); | 301 tab.SetData(data); |
158 EXPECT_TRUE(IconAnimationInvariant(tab)); | 302 EXPECT_TRUE(IconAnimationInvariant(tab)); |
159 EXPECT_EQ(TabRendererData::AUDIO_STATE_NONE, tab.data().audio_state); | |
160 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); | 303 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); |
161 data.capture_state = TabRendererData::CAPTURE_STATE_NONE; | 304 data.capture_state = TabRendererData::CAPTURE_STATE_NONE; |
162 tab.SetData(data); | 305 tab.SetData(data); |
163 EXPECT_TRUE(IconAnimationInvariant(tab)); | 306 EXPECT_TRUE(IconAnimationInvariant(tab)); |
164 EXPECT_EQ(TabRendererData::AUDIO_STATE_NONE, tab.data().audio_state); | |
165 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); | 307 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); |
166 EXPECT_TRUE(IconAnimationInvariant(tab)); | 308 EXPECT_TRUE(IconAnimationInvariant(tab)); |
167 | 309 |
168 // Audio starts then capture starts, then audio stops then capture stops. | 310 // Recording starts then tab capture starts, then back to just recording, then |
169 data.audio_state = TabRendererData::AUDIO_STATE_PLAYING; | 311 // recording stops. |
170 tab.SetData(data); | |
171 data.capture_state = TabRendererData::CAPTURE_STATE_RECORDING; | 312 data.capture_state = TabRendererData::CAPTURE_STATE_RECORDING; |
172 tab.SetData(data); | 313 tab.SetData(data); |
173 EXPECT_TRUE(IconAnimationInvariant(tab)); | 314 EXPECT_TRUE(IconAnimationInvariant(tab)); |
174 EXPECT_EQ(TabRendererData::AUDIO_STATE_PLAYING, tab.data().audio_state); | |
175 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); | 315 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); |
176 | 316 |
177 data.title = ASCIIToUTF16("test X"); | 317 data.title = ASCIIToUTF16("test X"); |
178 tab.SetData(data); | 318 tab.SetData(data); |
179 EXPECT_TRUE(IconAnimationInvariant(tab)); | 319 EXPECT_TRUE(IconAnimationInvariant(tab)); |
180 | 320 |
181 data.audio_state = TabRendererData::AUDIO_STATE_NONE; | 321 data.capture_state = TabRendererData::CAPTURE_STATE_PROJECTING; |
182 tab.SetData(data); | 322 tab.SetData(data); |
183 EXPECT_TRUE(IconAnimationInvariant(tab)); | 323 EXPECT_TRUE(IconAnimationInvariant(tab)); |
184 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); | 324 EXPECT_EQ(TabRendererData::CAPTURE_STATE_PROJECTING, |
185 data.capture_state = TabRendererData::CAPTURE_STATE_NONE; | 325 tab.data().capture_state); |
186 tab.SetData(data); | |
187 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
188 EXPECT_EQ(TabRendererData::AUDIO_STATE_NONE, tab.data().audio_state); | |
189 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); | |
190 | |
191 // Audio starts then capture starts, then capture stops then audio stops. | |
192 data.audio_state = TabRendererData::AUDIO_STATE_PLAYING; | |
193 tab.SetData(data); | |
194 data.capture_state = TabRendererData::CAPTURE_STATE_RECORDING; | |
195 tab.SetData(data); | |
196 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
197 EXPECT_EQ(TabRendererData::AUDIO_STATE_PLAYING, tab.data().audio_state); | |
198 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); | |
199 | 326 |
200 data.title = ASCIIToUTF16("test Y"); | 327 data.title = ASCIIToUTF16("test Y"); |
201 tab.SetData(data); | 328 tab.SetData(data); |
202 EXPECT_TRUE(IconAnimationInvariant(tab)); | 329 EXPECT_TRUE(IconAnimationInvariant(tab)); |
203 | 330 |
| 331 data.capture_state = TabRendererData::CAPTURE_STATE_RECORDING; |
| 332 tab.SetData(data); |
| 333 EXPECT_TRUE(IconAnimationInvariant(tab)); |
| 334 EXPECT_EQ(TabRendererData::CAPTURE_STATE_RECORDING, tab.data().capture_state); |
| 335 |
204 data.capture_state = TabRendererData::CAPTURE_STATE_NONE; | 336 data.capture_state = TabRendererData::CAPTURE_STATE_NONE; |
205 tab.SetData(data); | 337 tab.SetData(data); |
206 EXPECT_TRUE(IconAnimationInvariant(tab)); | 338 EXPECT_TRUE(IconAnimationInvariant(tab)); |
207 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); | 339 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); |
208 | |
209 data.audio_state = TabRendererData::AUDIO_STATE_NONE; | |
210 tab.SetData(data); | |
211 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
212 EXPECT_EQ(TabRendererData::AUDIO_STATE_NONE, tab.data().audio_state); | |
213 EXPECT_EQ(TabRendererData::CAPTURE_STATE_NONE, tab.data().capture_state); | |
214 EXPECT_TRUE(IconAnimationInvariant(tab)); | |
215 } | 340 } |
OLD | NEW |