| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "content/browser/web_contents/aura/window_slider.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/time/time.h" | |
| 9 #include "testing/gtest/include/gtest/gtest.h" | |
| 10 #include "ui/aura/test/aura_test_base.h" | |
| 11 #include "ui/aura/test/test_window_delegate.h" | |
| 12 #include "ui/aura/window.h" | |
| 13 #include "ui/base/hit_test.h" | |
| 14 #include "ui/compositor/scoped_animation_duration_scale_mode.h" | |
| 15 #include "ui/compositor/scoped_layer_animation_settings.h" | |
| 16 #include "ui/compositor/test/layer_animator_test_controller.h" | |
| 17 #include "ui/events/event_processor.h" | |
| 18 #include "ui/events/event_utils.h" | |
| 19 #include "ui/events/test/event_generator.h" | |
| 20 #include "ui/gfx/frame_time.h" | |
| 21 | |
| 22 namespace content { | |
| 23 | |
| 24 void DispatchEventDuringScrollCallback(ui::EventProcessor* dispatcher, | |
| 25 ui::Event* event, | |
| 26 ui::EventType type, | |
| 27 const gfx::Vector2dF& delta) { | |
| 28 if (type != ui::ET_GESTURE_SCROLL_UPDATE) | |
| 29 return; | |
| 30 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(event); | |
| 31 CHECK(!details.dispatcher_destroyed); | |
| 32 } | |
| 33 | |
| 34 void ChangeSliderOwnerDuringScrollCallback(scoped_ptr<aura::Window>* window, | |
| 35 WindowSlider* slider, | |
| 36 ui::EventType type, | |
| 37 const gfx::Vector2dF& delta) { | |
| 38 if (type != ui::ET_GESTURE_SCROLL_UPDATE) | |
| 39 return; | |
| 40 aura::Window* new_window = new aura::Window(NULL); | |
| 41 new_window->Init(ui::LAYER_TEXTURED); | |
| 42 new_window->Show(); | |
| 43 slider->ChangeOwner(new_window); | |
| 44 (*window)->parent()->AddChild(new_window); | |
| 45 window->reset(new_window); | |
| 46 } | |
| 47 | |
| 48 void ConfirmSlideDuringScrollCallback(WindowSlider* slider, | |
| 49 ui::EventType type, | |
| 50 const gfx::Vector2dF& delta) { | |
| 51 static float total_delta_x = 0; | |
| 52 if (type == ui::ET_GESTURE_SCROLL_BEGIN) | |
| 53 total_delta_x = 0; | |
| 54 | |
| 55 if (type == ui::ET_GESTURE_SCROLL_UPDATE) { | |
| 56 total_delta_x += delta.x(); | |
| 57 if (total_delta_x >= 70) | |
| 58 EXPECT_TRUE(slider->IsSlideInProgress()); | |
| 59 } else { | |
| 60 EXPECT_FALSE(slider->IsSlideInProgress()); | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 void ConfirmNoSlideDuringScrollCallback(WindowSlider* slider, | |
| 65 ui::EventType type, | |
| 66 const gfx::Vector2dF& delta) { | |
| 67 EXPECT_FALSE(slider->IsSlideInProgress()); | |
| 68 } | |
| 69 | |
| 70 // The window delegate does not receive any events. | |
| 71 class NoEventWindowDelegate : public aura::test::TestWindowDelegate { | |
| 72 public: | |
| 73 NoEventWindowDelegate() { | |
| 74 } | |
| 75 ~NoEventWindowDelegate() override {} | |
| 76 | |
| 77 private: | |
| 78 // Overridden from aura::WindowDelegate: | |
| 79 bool HasHitTestMask() const override { return true; } | |
| 80 | |
| 81 DISALLOW_COPY_AND_ASSIGN(NoEventWindowDelegate); | |
| 82 }; | |
| 83 | |
| 84 class WindowSliderDelegateTest : public WindowSlider::Delegate { | |
| 85 public: | |
| 86 WindowSliderDelegateTest() | |
| 87 : can_create_layer_(true), | |
| 88 created_back_layer_(false), | |
| 89 created_front_layer_(false), | |
| 90 slide_completing_(false), | |
| 91 slide_completed_(false), | |
| 92 slide_aborted_(false), | |
| 93 slider_destroyed_(false) { | |
| 94 } | |
| 95 ~WindowSliderDelegateTest() override { | |
| 96 // Make sure slide_completed() gets called if slide_completing() was called. | |
| 97 CHECK(!slide_completing_ || slide_completed_); | |
| 98 } | |
| 99 | |
| 100 void Reset() { | |
| 101 can_create_layer_ = true; | |
| 102 created_back_layer_ = false; | |
| 103 created_front_layer_ = false; | |
| 104 slide_completing_ = false; | |
| 105 slide_completed_ = false; | |
| 106 slide_aborted_ = false; | |
| 107 slider_destroyed_ = false; | |
| 108 } | |
| 109 | |
| 110 void SetCanCreateLayer(bool can_create_layer) { | |
| 111 can_create_layer_ = can_create_layer; | |
| 112 } | |
| 113 | |
| 114 bool created_back_layer() const { return created_back_layer_; } | |
| 115 bool created_front_layer() const { return created_front_layer_; } | |
| 116 bool slide_completing() const { return slide_completing_; } | |
| 117 bool slide_completed() const { return slide_completed_; } | |
| 118 bool slide_aborted() const { return slide_aborted_; } | |
| 119 bool slider_destroyed() const { return slider_destroyed_; } | |
| 120 | |
| 121 protected: | |
| 122 ui::Layer* CreateLayerForTest() { | |
| 123 CHECK(can_create_layer_); | |
| 124 ui::Layer* layer = new ui::Layer(ui::LAYER_SOLID_COLOR); | |
| 125 layer->SetColor(SK_ColorRED); | |
| 126 return layer; | |
| 127 } | |
| 128 | |
| 129 // Overridden from WindowSlider::Delegate: | |
| 130 ui::Layer* CreateBackLayer() override { | |
| 131 if (!can_create_layer_) | |
| 132 return NULL; | |
| 133 created_back_layer_ = true; | |
| 134 return CreateLayerForTest(); | |
| 135 } | |
| 136 | |
| 137 ui::Layer* CreateFrontLayer() override { | |
| 138 if (!can_create_layer_) | |
| 139 return NULL; | |
| 140 created_front_layer_ = true; | |
| 141 return CreateLayerForTest(); | |
| 142 } | |
| 143 | |
| 144 void OnWindowSlideCompleted(scoped_ptr<ui::Layer> layer) override { | |
| 145 slide_completed_ = true; | |
| 146 } | |
| 147 | |
| 148 void OnWindowSlideCompleting() override { slide_completing_ = true; } | |
| 149 | |
| 150 void OnWindowSlideAborted() override { slide_aborted_ = true; } | |
| 151 | |
| 152 void OnWindowSliderDestroyed() override { slider_destroyed_ = true; } | |
| 153 | |
| 154 private: | |
| 155 bool can_create_layer_; | |
| 156 bool created_back_layer_; | |
| 157 bool created_front_layer_; | |
| 158 bool slide_completing_; | |
| 159 bool slide_completed_; | |
| 160 bool slide_aborted_; | |
| 161 bool slider_destroyed_; | |
| 162 | |
| 163 DISALLOW_COPY_AND_ASSIGN(WindowSliderDelegateTest); | |
| 164 }; | |
| 165 | |
| 166 // This delegate destroys the owner window when the slider is destroyed. | |
| 167 class WindowSliderDeleteOwnerOnDestroy : public WindowSliderDelegateTest { | |
| 168 public: | |
| 169 explicit WindowSliderDeleteOwnerOnDestroy(aura::Window* owner) | |
| 170 : owner_(owner) { | |
| 171 } | |
| 172 ~WindowSliderDeleteOwnerOnDestroy() override {} | |
| 173 | |
| 174 private: | |
| 175 // Overridden from WindowSlider::Delegate: | |
| 176 void OnWindowSliderDestroyed() override { | |
| 177 WindowSliderDelegateTest::OnWindowSliderDestroyed(); | |
| 178 delete owner_; | |
| 179 } | |
| 180 | |
| 181 aura::Window* owner_; | |
| 182 DISALLOW_COPY_AND_ASSIGN(WindowSliderDeleteOwnerOnDestroy); | |
| 183 }; | |
| 184 | |
| 185 // This delegate destroyes the owner window when a slide is completed. | |
| 186 class WindowSliderDeleteOwnerOnComplete : public WindowSliderDelegateTest { | |
| 187 public: | |
| 188 explicit WindowSliderDeleteOwnerOnComplete(aura::Window* owner) | |
| 189 : owner_(owner) { | |
| 190 } | |
| 191 ~WindowSliderDeleteOwnerOnComplete() override {} | |
| 192 | |
| 193 private: | |
| 194 // Overridden from WindowSlider::Delegate: | |
| 195 void OnWindowSlideCompleted(scoped_ptr<ui::Layer> layer) override { | |
| 196 WindowSliderDelegateTest::OnWindowSlideCompleted(layer.Pass()); | |
| 197 delete owner_; | |
| 198 } | |
| 199 | |
| 200 aura::Window* owner_; | |
| 201 DISALLOW_COPY_AND_ASSIGN(WindowSliderDeleteOwnerOnComplete); | |
| 202 }; | |
| 203 | |
| 204 typedef aura::test::AuraTestBase WindowSliderTest; | |
| 205 | |
| 206 TEST_F(WindowSliderTest, WindowSlideUsingGesture) { | |
| 207 scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL)); | |
| 208 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 209 WindowSliderDelegateTest slider_delegate; | |
| 210 | |
| 211 ui::test::EventGenerator generator(root_window()); | |
| 212 | |
| 213 // Generate a horizontal overscroll. | |
| 214 WindowSlider* slider = | |
| 215 new WindowSlider(&slider_delegate, root_window(), window.get()); | |
| 216 generator.GestureScrollSequenceWithCallback( | |
| 217 gfx::Point(10, 10), | |
| 218 gfx::Point(180, 10), | |
| 219 base::TimeDelta::FromMilliseconds(10), | |
| 220 10, | |
| 221 base::Bind(&ConfirmSlideDuringScrollCallback, slider)); | |
| 222 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 223 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 224 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 225 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 226 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 227 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 228 EXPECT_FALSE(slider->IsSlideInProgress()); | |
| 229 slider_delegate.Reset(); | |
| 230 window->SetTransform(gfx::Transform()); | |
| 231 | |
| 232 // Generate a horizontal overscroll in the reverse direction. | |
| 233 generator.GestureScrollSequenceWithCallback( | |
| 234 gfx::Point(180, 10), | |
| 235 gfx::Point(10, 10), | |
| 236 base::TimeDelta::FromMilliseconds(10), | |
| 237 10, | |
| 238 base::Bind(&ConfirmSlideDuringScrollCallback, slider)); | |
| 239 EXPECT_TRUE(slider_delegate.created_front_layer()); | |
| 240 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 241 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 242 EXPECT_FALSE(slider_delegate.created_back_layer()); | |
| 243 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 244 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 245 EXPECT_FALSE(slider->IsSlideInProgress()); | |
| 246 slider_delegate.Reset(); | |
| 247 | |
| 248 // Generate a vertical overscroll. | |
| 249 generator.GestureScrollSequenceWithCallback( | |
| 250 gfx::Point(10, 10), | |
| 251 gfx::Point(10, 80), | |
| 252 base::TimeDelta::FromMilliseconds(10), | |
| 253 10, | |
| 254 base::Bind(&ConfirmNoSlideDuringScrollCallback, slider)); | |
| 255 EXPECT_FALSE(slider_delegate.created_back_layer()); | |
| 256 EXPECT_FALSE(slider_delegate.slide_completing()); | |
| 257 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 258 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 259 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 260 EXPECT_FALSE(slider->IsSlideInProgress()); | |
| 261 slider_delegate.Reset(); | |
| 262 | |
| 263 // Generate a horizontal scroll that starts overscroll, but doesn't scroll | |
| 264 // enough to complete it. | |
| 265 generator.GestureScrollSequenceWithCallback( | |
| 266 gfx::Point(10, 10), | |
| 267 gfx::Point(80, 10), | |
| 268 base::TimeDelta::FromMilliseconds(10), | |
| 269 10, | |
| 270 base::Bind(&ConfirmSlideDuringScrollCallback, slider)); | |
| 271 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 272 EXPECT_TRUE(slider_delegate.slide_aborted()); | |
| 273 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 274 EXPECT_FALSE(slider_delegate.slide_completing()); | |
| 275 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 276 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 277 EXPECT_FALSE(slider->IsSlideInProgress()); | |
| 278 slider_delegate.Reset(); | |
| 279 | |
| 280 // Destroy the window. This should destroy the slider. | |
| 281 window.reset(); | |
| 282 EXPECT_TRUE(slider_delegate.slider_destroyed()); | |
| 283 } | |
| 284 | |
| 285 // Tests that the window slide is interrupted when a different type of event | |
| 286 // happens. | |
| 287 TEST_F(WindowSliderTest, WindowSlideIsCancelledOnEvent) { | |
| 288 scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL)); | |
| 289 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 290 WindowSliderDelegateTest slider_delegate; | |
| 291 | |
| 292 ui::Event* events[] = { | |
| 293 new ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(55, 10), | |
| 294 gfx::Point(55, 10), ui::EventTimeForNow(), 0, 0), | |
| 295 new ui::KeyEvent('a', ui::VKEY_A, ui::EF_NONE), | |
| 296 nullptr | |
| 297 }; | |
| 298 | |
| 299 new WindowSlider(&slider_delegate, root_window(), window.get()); | |
| 300 for (int i = 0; events[i]; ++i) { | |
| 301 // Generate a horizontal overscroll. | |
| 302 ui::test::EventGenerator generator(root_window()); | |
| 303 generator.GestureScrollSequenceWithCallback( | |
| 304 gfx::Point(10, 10), | |
| 305 gfx::Point(80, 10), | |
| 306 base::TimeDelta::FromMilliseconds(10), | |
| 307 1, | |
| 308 base::Bind(&DispatchEventDuringScrollCallback, | |
| 309 root_window()->GetHost()->event_processor(), | |
| 310 base::Owned(events[i]))); | |
| 311 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 312 EXPECT_TRUE(slider_delegate.slide_aborted()); | |
| 313 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 314 EXPECT_FALSE(slider_delegate.slide_completing()); | |
| 315 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 316 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 317 slider_delegate.Reset(); | |
| 318 } | |
| 319 window.reset(); | |
| 320 EXPECT_TRUE(slider_delegate.slider_destroyed()); | |
| 321 } | |
| 322 | |
| 323 // Tests that the window slide can continue after it is interrupted by another | |
| 324 // event if the user continues scrolling. | |
| 325 TEST_F(WindowSliderTest, WindowSlideInterruptedThenContinues) { | |
| 326 scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL)); | |
| 327 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 328 WindowSliderDelegateTest slider_delegate; | |
| 329 | |
| 330 ui::ScopedAnimationDurationScaleMode normal_duration_( | |
| 331 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION); | |
| 332 ui::LayerAnimator* animator = window->layer()->GetAnimator(); | |
| 333 animator->set_disable_timer_for_test(true); | |
| 334 ui::LayerAnimatorTestController test_controller(animator); | |
| 335 | |
| 336 WindowSlider* slider = | |
| 337 new WindowSlider(&slider_delegate, root_window(), window.get()); | |
| 338 | |
| 339 ui::MouseEvent interrupt_event(ui::ET_MOUSE_MOVED, gfx::Point(55, 10), | |
| 340 gfx::Point(55, 10), ui::EventTimeForNow(), 0, | |
| 341 0); | |
| 342 | |
| 343 ui::test::EventGenerator generator(root_window()); | |
| 344 | |
| 345 // Start the scroll sequence. Scroll forward so that |window|'s layer is the | |
| 346 // one animating. | |
| 347 const int kTouchId = 5; | |
| 348 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, | |
| 349 gfx::Point(10, 10), | |
| 350 kTouchId, | |
| 351 ui::EventTimeForNow()); | |
| 352 generator.Dispatch(&press); | |
| 353 | |
| 354 // First scroll event of the sequence. | |
| 355 ui::TouchEvent move1(ui::ET_TOUCH_MOVED, | |
| 356 gfx::Point(100, 10), | |
| 357 kTouchId, | |
| 358 ui::EventTimeForNow()); | |
| 359 generator.Dispatch(&move1); | |
| 360 EXPECT_TRUE(slider->IsSlideInProgress()); | |
| 361 EXPECT_FALSE(animator->is_animating()); | |
| 362 // Dispatch the event after the first scroll and confirm it interrupts the | |
| 363 // scroll and starts the "reset slide" animation. | |
| 364 generator.Dispatch(&interrupt_event); | |
| 365 EXPECT_TRUE(slider->IsSlideInProgress()); | |
| 366 EXPECT_TRUE(animator->is_animating()); | |
| 367 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 368 // slide_aborted() should be false because the 'reset slide' animation | |
| 369 // hasn't completed yet. | |
| 370 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 371 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 372 EXPECT_FALSE(slider_delegate.slide_completing()); | |
| 373 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 374 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 375 slider_delegate.Reset(); | |
| 376 | |
| 377 // Second scroll event of the sequence. | |
| 378 ui::TouchEvent move2(ui::ET_TOUCH_MOVED, | |
| 379 gfx::Point(200, 10), | |
| 380 kTouchId, | |
| 381 ui::EventTimeForNow()); | |
| 382 generator.Dispatch(&move2); | |
| 383 // The second scroll should instantly cause the animation to complete. | |
| 384 EXPECT_FALSE(animator->is_animating()); | |
| 385 EXPECT_FALSE(slider_delegate.created_back_layer()); | |
| 386 // The ResetScroll() animation was completed, so now slide_aborted() | |
| 387 // should be true. | |
| 388 EXPECT_TRUE(slider_delegate.slide_aborted()); | |
| 389 | |
| 390 // Third scroll event of the sequence. | |
| 391 ui::TouchEvent move3(ui::ET_TOUCH_MOVED, | |
| 392 gfx::Point(300, 10), | |
| 393 kTouchId, | |
| 394 ui::EventTimeForNow()); | |
| 395 generator.Dispatch(&move3); | |
| 396 // The third scroll should re-start the sliding. | |
| 397 EXPECT_TRUE(slider->IsSlideInProgress()); | |
| 398 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 399 | |
| 400 // Generate the release event, finishing the scroll sequence. | |
| 401 ui::TouchEvent release(ui::ET_TOUCH_RELEASED, | |
| 402 gfx::Point(300, 10), | |
| 403 kTouchId, | |
| 404 ui::EventTimeForNow()); | |
| 405 generator.Dispatch(&release); | |
| 406 // When the scroll gesture ends, the slide animation should start. | |
| 407 EXPECT_TRUE(slider->IsSlideInProgress()); | |
| 408 EXPECT_TRUE(animator->is_animating()); | |
| 409 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 410 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 411 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 412 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 413 | |
| 414 // Progress the animator to complete the slide animation. | |
| 415 ui::ScopedLayerAnimationSettings settings(animator); | |
| 416 base::TimeDelta duration = settings.GetTransitionDuration(); | |
| 417 test_controller.StartThreadedAnimationsIfNeeded(); | |
| 418 animator->Step(gfx::FrameTime::Now() + duration); | |
| 419 | |
| 420 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 421 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 422 | |
| 423 window.reset(); | |
| 424 EXPECT_TRUE(slider_delegate.slider_destroyed()); | |
| 425 } | |
| 426 | |
| 427 // Tests that the slide works correctly when the owner of the window changes | |
| 428 // during the duration of the slide. | |
| 429 TEST_F(WindowSliderTest, OwnerWindowChangesDuringWindowSlide) { | |
| 430 scoped_ptr<aura::Window> parent(CreateNormalWindow(0, root_window(), NULL)); | |
| 431 | |
| 432 NoEventWindowDelegate window_delegate; | |
| 433 window_delegate.set_window_component(HTNOWHERE); | |
| 434 scoped_ptr<aura::Window> window(CreateNormalWindow(1, parent.get(), | |
| 435 &window_delegate)); | |
| 436 | |
| 437 WindowSliderDelegateTest slider_delegate; | |
| 438 scoped_ptr<WindowSlider> slider( | |
| 439 new WindowSlider(&slider_delegate, parent.get(), window.get())); | |
| 440 | |
| 441 // Generate a horizontal scroll, and change the owner in the middle of the | |
| 442 // scroll. | |
| 443 ui::test::EventGenerator generator(root_window()); | |
| 444 aura::Window* old_window = window.get(); | |
| 445 generator.GestureScrollSequenceWithCallback( | |
| 446 gfx::Point(10, 10), | |
| 447 gfx::Point(80, 10), | |
| 448 base::TimeDelta::FromMilliseconds(10), | |
| 449 1, | |
| 450 base::Bind(&ChangeSliderOwnerDuringScrollCallback, | |
| 451 base::Unretained(&window), | |
| 452 slider.get())); | |
| 453 aura::Window* new_window = window.get(); | |
| 454 EXPECT_NE(old_window, new_window); | |
| 455 | |
| 456 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 457 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 458 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 459 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 460 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 461 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 462 } | |
| 463 | |
| 464 // If the delegate doesn't create the layer to show while sliding, WindowSlider | |
| 465 // shouldn't start the slide or change delegate's state in any way in response | |
| 466 // to user input. | |
| 467 TEST_F(WindowSliderTest, NoSlideWhenLayerCantBeCreated) { | |
| 468 scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL)); | |
| 469 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 470 WindowSliderDelegateTest slider_delegate; | |
| 471 slider_delegate.SetCanCreateLayer(false); | |
| 472 WindowSlider* slider = | |
| 473 new WindowSlider(&slider_delegate, root_window(), window.get()); | |
| 474 | |
| 475 ui::test::EventGenerator generator(root_window()); | |
| 476 | |
| 477 // No slide in progress should be reported during scroll since the layer | |
| 478 // wasn't created. | |
| 479 generator.GestureScrollSequenceWithCallback( | |
| 480 gfx::Point(10, 10), | |
| 481 gfx::Point(180, 10), | |
| 482 base::TimeDelta::FromMilliseconds(10), | |
| 483 1, | |
| 484 base::Bind(&ConfirmNoSlideDuringScrollCallback, slider)); | |
| 485 | |
| 486 EXPECT_FALSE(slider_delegate.created_back_layer()); | |
| 487 EXPECT_FALSE(slider_delegate.slide_completing()); | |
| 488 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 489 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 490 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 491 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 492 window->SetTransform(gfx::Transform()); | |
| 493 | |
| 494 slider_delegate.SetCanCreateLayer(true); | |
| 495 generator.GestureScrollSequenceWithCallback( | |
| 496 gfx::Point(10, 10), | |
| 497 gfx::Point(180, 10), | |
| 498 base::TimeDelta::FromMilliseconds(10), | |
| 499 10, | |
| 500 base::Bind(&ConfirmSlideDuringScrollCallback, slider)); | |
| 501 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 502 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 503 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 504 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 505 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 506 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 507 | |
| 508 window.reset(); | |
| 509 EXPECT_TRUE(slider_delegate.slider_destroyed()); | |
| 510 } | |
| 511 | |
| 512 // Tests that the owner window can be destroyed from |OnWindowSliderDestroyed()| | |
| 513 // delegate callback without causing a crash. | |
| 514 TEST_F(WindowSliderTest, OwnerIsDestroyedOnSliderDestroy) { | |
| 515 size_t child_windows = root_window()->children().size(); | |
| 516 aura::Window* window = CreateNormalWindow(0, root_window(), NULL); | |
| 517 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 518 EXPECT_EQ(child_windows + 1, root_window()->children().size()); | |
| 519 | |
| 520 WindowSliderDeleteOwnerOnDestroy slider_delegate(window); | |
| 521 ui::test::EventGenerator generator(root_window()); | |
| 522 | |
| 523 // Generate a horizontal overscroll. | |
| 524 scoped_ptr<WindowSlider> slider( | |
| 525 new WindowSlider(&slider_delegate, root_window(), window)); | |
| 526 generator.GestureScrollSequence(gfx::Point(10, 10), | |
| 527 gfx::Point(180, 10), | |
| 528 base::TimeDelta::FromMilliseconds(10), | |
| 529 10); | |
| 530 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 531 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 532 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 533 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 534 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 535 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 536 | |
| 537 slider.reset(); | |
| 538 // Destroying the slider would have destroyed |window| too. So |window| should | |
| 539 // not need to be destroyed here. | |
| 540 EXPECT_EQ(child_windows, root_window()->children().size()); | |
| 541 } | |
| 542 | |
| 543 // Tests that the owner window can be destroyed from |OnWindowSlideComplete()| | |
| 544 // delegate callback without causing a crash. | |
| 545 TEST_F(WindowSliderTest, OwnerIsDestroyedOnSlideComplete) { | |
| 546 size_t child_windows = root_window()->children().size(); | |
| 547 aura::Window* window = CreateNormalWindow(0, root_window(), NULL); | |
| 548 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 549 EXPECT_EQ(child_windows + 1, root_window()->children().size()); | |
| 550 | |
| 551 WindowSliderDeleteOwnerOnComplete slider_delegate(window); | |
| 552 ui::test::EventGenerator generator(root_window()); | |
| 553 | |
| 554 // Generate a horizontal overscroll. | |
| 555 new WindowSlider(&slider_delegate, root_window(), window); | |
| 556 generator.GestureScrollSequence(gfx::Point(10, 10), | |
| 557 gfx::Point(180, 10), | |
| 558 base::TimeDelta::FromMilliseconds(10), | |
| 559 10); | |
| 560 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 561 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 562 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 563 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 564 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 565 EXPECT_TRUE(slider_delegate.slider_destroyed()); | |
| 566 | |
| 567 // Destroying the slider would have destroyed |window| too. So |window| should | |
| 568 // not need to be destroyed here. | |
| 569 EXPECT_EQ(child_windows, root_window()->children().size()); | |
| 570 } | |
| 571 | |
| 572 // Test the scenario when two swipe gesture occur quickly one after another so | |
| 573 // that the second swipe occurs while the transition animation triggered by the | |
| 574 // first swipe is in progress. | |
| 575 // The second swipe is supposed to instantly complete the animation caused by | |
| 576 // the first swipe, ask the delegate to create a new layer, and animate it. | |
| 577 TEST_F(WindowSliderTest, SwipeDuringSwipeAnimation) { | |
| 578 scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL)); | |
| 579 window->SetBounds(gfx::Rect(0, 0, 400, 400)); | |
| 580 WindowSliderDelegateTest slider_delegate; | |
| 581 new WindowSlider(&slider_delegate, root_window(), window.get()); | |
| 582 | |
| 583 // This test uses explicit durations so needs a normal duration. | |
| 584 ui::ScopedAnimationDurationScaleMode normal_duration( | |
| 585 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION); | |
| 586 ui::LayerAnimator* animator = window->layer()->GetAnimator(); | |
| 587 animator->set_disable_timer_for_test(true); | |
| 588 ui::LayerAnimatorTestController test_controller(animator); | |
| 589 | |
| 590 ui::test::EventGenerator generator(root_window()); | |
| 591 | |
| 592 // Swipe forward so that |window|'s layer is the one animating. | |
| 593 generator.GestureScrollSequence( | |
| 594 gfx::Point(10, 10), | |
| 595 gfx::Point(180, 10), | |
| 596 base::TimeDelta::FromMilliseconds(10), | |
| 597 2); | |
| 598 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 599 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 600 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 601 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 602 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 603 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 604 ui::ScopedLayerAnimationSettings settings(animator); | |
| 605 base::TimeDelta duration = settings.GetTransitionDuration(); | |
| 606 test_controller.StartThreadedAnimationsIfNeeded(); | |
| 607 base::TimeTicks start_time1 = gfx::FrameTime::Now(); | |
| 608 | |
| 609 animator->Step(start_time1 + duration / 2); | |
| 610 EXPECT_FALSE(slider_delegate.slide_completed()); | |
| 611 slider_delegate.Reset(); | |
| 612 // Generate another horizontal swipe while the animation from the previous | |
| 613 // swipe is in progress. | |
| 614 generator.GestureScrollSequence( | |
| 615 gfx::Point(10, 10), | |
| 616 gfx::Point(180, 10), | |
| 617 base::TimeDelta::FromMilliseconds(10), | |
| 618 2); | |
| 619 // Performing the second swipe should instantly complete the slide started | |
| 620 // by the first swipe and create a new layer. | |
| 621 EXPECT_TRUE(slider_delegate.created_back_layer()); | |
| 622 EXPECT_FALSE(slider_delegate.slide_aborted()); | |
| 623 EXPECT_FALSE(slider_delegate.created_front_layer()); | |
| 624 EXPECT_TRUE(slider_delegate.slide_completing()); | |
| 625 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 626 EXPECT_FALSE(slider_delegate.slider_destroyed()); | |
| 627 test_controller.StartThreadedAnimationsIfNeeded(); | |
| 628 base::TimeTicks start_time2 = gfx::FrameTime::Now(); | |
| 629 slider_delegate.Reset(); | |
| 630 animator->Step(start_time2 + duration); | |
| 631 // The animation for the second slide should now be completed. | |
| 632 EXPECT_TRUE(slider_delegate.slide_completed()); | |
| 633 slider_delegate.Reset(); | |
| 634 | |
| 635 window.reset(); | |
| 636 EXPECT_TRUE(slider_delegate.slider_destroyed()); | |
| 637 } | |
| 638 | |
| 639 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 895543005:
Refactor GestureNavigation to eliminate code redundancy (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master