Home | History | Annotate | Download | only in aura 
      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 "testing/gtest/include/gtest/gtest.h"
      9 #include "ui/aura/root_window.h"
     10 #include "ui/aura/test/aura_test_base.h"
     11 #include "ui/aura/test/event_generator.h"
     12 #include "ui/aura/test/test_window_delegate.h"
     13 #include "ui/aura/window.h"
     14 #include "ui/base/hit_test.h"
     15 
     16 namespace content {
     17 
     18 void DispatchEventDuringScrollCallback(aura::RootWindow* root_window,
     19                                        ui::Event* event,
     20                                        ui::EventType type,
     21                                        const gfx::Vector2dF& delta) {
     22   if (type != ui::ET_GESTURE_SCROLL_UPDATE)
     23     return;
     24   aura::RootWindowHostDelegate* delegate =
     25       root_window->AsRootWindowHostDelegate();
     26   if (event->IsMouseEvent())
     27     delegate->OnHostMouseEvent(static_cast<ui::MouseEvent*>(event));
     28   else if (event->IsKeyEvent())
     29     delegate->OnHostKeyEvent(static_cast<ui::KeyEvent*>(event));
     30 }
     31 
     32 void ChangeSliderOwnerDuringScrollCallback(scoped_ptr<aura::Window>* window,
     33                                            WindowSlider* slider,
     34                                            ui::EventType type,
     35                                            const gfx::Vector2dF& delta) {
     36   if (type != ui::ET_GESTURE_SCROLL_UPDATE)
     37     return;
     38   aura::Window* new_window = new aura::Window(NULL);
     39   new_window->Init(ui::LAYER_TEXTURED);
     40   new_window->Show();
     41   slider->ChangeOwner(new_window);
     42   (*window)->parent()->AddChild(new_window);
     43   window->reset(new_window);
     44 }
     45 
     46 // The window delegate does not receive any events.
     47 class NoEventWindowDelegate : public aura::test::TestWindowDelegate {
     48  public:
     49   NoEventWindowDelegate() {
     50   }
     51   virtual ~NoEventWindowDelegate() {}
     52 
     53  private:
     54   // Overridden from aura::WindowDelegate:
     55   virtual bool HasHitTestMask() const OVERRIDE { return true; }
     56 
     57   DISALLOW_COPY_AND_ASSIGN(NoEventWindowDelegate);
     58 };
     59 
     60 class WindowSliderDelegateTest : public WindowSlider::Delegate {
     61  public:
     62   WindowSliderDelegateTest()
     63       : can_create_layer_(true),
     64         created_back_layer_(false),
     65         created_front_layer_(false),
     66         slide_completed_(false),
     67         slide_aborted_(false),
     68         slider_destroyed_(false) {
     69   }
     70   virtual ~WindowSliderDelegateTest() {}
     71 
     72   void Reset() {
     73     can_create_layer_ = true;
     74     created_back_layer_ = false;
     75     created_front_layer_ = false;
     76     slide_completed_ = false;
     77     slide_aborted_ = false;
     78     slider_destroyed_ = false;
     79   }
     80 
     81   void SetCanCreateLayer(bool can_create_layer) {
     82     can_create_layer_ = can_create_layer;
     83   }
     84 
     85   bool created_back_layer() const { return created_back_layer_; }
     86   bool created_front_layer() const { return created_front_layer_; }
     87   bool slide_completed() const { return slide_completed_; }
     88   bool slide_aborted() const { return slide_aborted_; }
     89   bool slider_destroyed() const { return slider_destroyed_; }
     90 
     91  protected:
     92   ui::Layer* CreateLayerForTest() {
     93     CHECK(can_create_layer_);
     94     ui::Layer* layer = new ui::Layer(ui::LAYER_SOLID_COLOR);
     95     layer->SetColor(SK_ColorRED);
     96     return layer;
     97   }
     98 
     99   // Overridden from WindowSlider::Delegate:
    100   virtual ui::Layer* CreateBackLayer() OVERRIDE {
    101     if (!can_create_layer_)
    102       return NULL;
    103     created_back_layer_ = true;
    104     return CreateLayerForTest();
    105   }
    106 
    107   virtual ui::Layer* CreateFrontLayer() OVERRIDE {
    108     if (!can_create_layer_)
    109       return NULL;
    110     created_front_layer_ = true;
    111     return CreateLayerForTest();
    112   }
    113 
    114   virtual void OnWindowSlideComplete() OVERRIDE {
    115     slide_completed_ = true;
    116   }
    117 
    118   virtual void OnWindowSlideAborted() OVERRIDE {
    119     slide_aborted_ = true;
    120   }
    121 
    122   virtual void OnWindowSliderDestroyed() OVERRIDE {
    123     slider_destroyed_ = true;
    124   }
    125 
    126  private:
    127   bool can_create_layer_;
    128   bool created_back_layer_;
    129   bool created_front_layer_;
    130   bool slide_completed_;
    131   bool slide_aborted_;
    132   bool slider_destroyed_;
    133 
    134   DISALLOW_COPY_AND_ASSIGN(WindowSliderDelegateTest);
    135 };
    136 
    137 // This delegate destroys the owner window when the slider is destroyed.
    138 class WindowSliderDeleteOwnerOnDestroy : public WindowSliderDelegateTest {
    139  public:
    140   explicit WindowSliderDeleteOwnerOnDestroy(aura::Window* owner)
    141       : owner_(owner) {
    142   }
    143   virtual ~WindowSliderDeleteOwnerOnDestroy() {}
    144 
    145  private:
    146   // Overridden from WindowSlider::Delegate:
    147   virtual void OnWindowSliderDestroyed() OVERRIDE {
    148     WindowSliderDelegateTest::OnWindowSliderDestroyed();
    149     delete owner_;
    150   }
    151 
    152   aura::Window* owner_;
    153   DISALLOW_COPY_AND_ASSIGN(WindowSliderDeleteOwnerOnDestroy);
    154 };
    155 
    156 // This delegate destroyes the owner window when a slide is completed.
    157 class WindowSliderDeleteOwnerOnComplete : public WindowSliderDelegateTest {
    158  public:
    159   explicit WindowSliderDeleteOwnerOnComplete(aura::Window* owner)
    160       : owner_(owner) {
    161   }
    162   virtual ~WindowSliderDeleteOwnerOnComplete() {}
    163 
    164  private:
    165   // Overridden from WindowSlider::Delegate:
    166   virtual void OnWindowSlideComplete() OVERRIDE {
    167     WindowSliderDelegateTest::OnWindowSlideComplete();
    168     delete owner_;
    169   }
    170 
    171   aura::Window* owner_;
    172   DISALLOW_COPY_AND_ASSIGN(WindowSliderDeleteOwnerOnComplete);
    173 };
    174 
    175 typedef aura::test::AuraTestBase WindowSliderTest;
    176 
    177 TEST_F(WindowSliderTest, WindowSlideUsingGesture) {
    178   scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL));
    179   window->SetBounds(gfx::Rect(0, 0, 400, 400));
    180   WindowSliderDelegateTest slider_delegate;
    181 
    182   aura::test::EventGenerator generator(root_window());
    183 
    184   // Generate a horizontal overscroll.
    185   WindowSlider* slider =
    186       new WindowSlider(&slider_delegate, root_window(), window.get());
    187   generator.GestureScrollSequence(gfx::Point(10, 10),
    188                                   gfx::Point(160, 10),
    189                                   base::TimeDelta::FromMilliseconds(10),
    190                                   10);
    191   EXPECT_TRUE(slider_delegate.created_back_layer());
    192   EXPECT_TRUE(slider_delegate.slide_completed());
    193   EXPECT_FALSE(slider_delegate.created_front_layer());
    194   EXPECT_FALSE(slider_delegate.slide_aborted());
    195   EXPECT_FALSE(slider_delegate.slider_destroyed());
    196   EXPECT_FALSE(slider->IsSlideInProgress());
    197   slider_delegate.Reset();
    198   window->SetTransform(gfx::Transform());
    199 
    200   // Generat a horizontal overscroll in the reverse direction.
    201   generator.GestureScrollSequence(gfx::Point(160, 10),
    202                                   gfx::Point(10, 10),
    203                                   base::TimeDelta::FromMilliseconds(10),
    204                                   10);
    205   EXPECT_TRUE(slider_delegate.created_front_layer());
    206   EXPECT_TRUE(slider_delegate.slide_completed());
    207   EXPECT_FALSE(slider_delegate.created_back_layer());
    208   EXPECT_FALSE(slider_delegate.slide_aborted());
    209   EXPECT_FALSE(slider_delegate.slider_destroyed());
    210   EXPECT_FALSE(slider->IsSlideInProgress());
    211   slider_delegate.Reset();
    212 
    213   // Generate a vertical overscroll.
    214   generator.GestureScrollSequence(gfx::Point(10, 10),
    215                                   gfx::Point(10, 80),
    216                                   base::TimeDelta::FromMilliseconds(10),
    217                                   10);
    218   EXPECT_FALSE(slider_delegate.created_back_layer());
    219   EXPECT_FALSE(slider_delegate.slide_completed());
    220   EXPECT_FALSE(slider_delegate.created_front_layer());
    221   EXPECT_FALSE(slider_delegate.slide_aborted());
    222   EXPECT_FALSE(slider->IsSlideInProgress());
    223   slider_delegate.Reset();
    224 
    225   // Generate a horizontal scroll that starts overscroll, but doesn't scroll
    226   // enough to complete it.
    227   generator.GestureScrollSequence(gfx::Point(10, 10),
    228                                   gfx::Point(60, 10),
    229                                   base::TimeDelta::FromMilliseconds(10),
    230                                   10);
    231   EXPECT_TRUE(slider_delegate.created_back_layer());
    232   EXPECT_TRUE(slider_delegate.slide_aborted());
    233   EXPECT_FALSE(slider_delegate.created_front_layer());
    234   EXPECT_FALSE(slider_delegate.slide_completed());
    235   EXPECT_FALSE(slider_delegate.slider_destroyed());
    236   EXPECT_FALSE(slider->IsSlideInProgress());
    237   slider_delegate.Reset();
    238 
    239   // Destroy the window. This should destroy the slider.
    240   window.reset();
    241   EXPECT_TRUE(slider_delegate.slider_destroyed());
    242 }
    243 
    244 // Tests that the window slide is cancelled when a different type of event
    245 // happens.
    246 TEST_F(WindowSliderTest, WindowSlideIsCancelledOnEvent) {
    247   scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL));
    248   WindowSliderDelegateTest slider_delegate;
    249 
    250   ui::Event* events[] = {
    251     new ui::MouseEvent(ui::ET_MOUSE_MOVED,
    252                        gfx::Point(55, 10),
    253                        gfx::Point(55, 10),
    254                        0),
    255     new ui::KeyEvent(ui::ET_KEY_PRESSED,
    256                      ui::VKEY_A,
    257                      0,
    258                      true),
    259     NULL
    260   };
    261 
    262   new WindowSlider(&slider_delegate, root_window(), window.get());
    263   for (int i = 0; events[i]; ++i) {
    264     // Generate a horizontal overscroll.
    265     aura::test::EventGenerator generator(root_window());
    266     generator.GestureScrollSequenceWithCallback(
    267         gfx::Point(10, 10),
    268         gfx::Point(80, 10),
    269         base::TimeDelta::FromMilliseconds(10),
    270         1,
    271         base::Bind(&DispatchEventDuringScrollCallback,
    272                    root_window(),
    273                    base::Owned(events[i])));
    274     EXPECT_TRUE(slider_delegate.created_back_layer());
    275     EXPECT_TRUE(slider_delegate.slide_aborted());
    276     EXPECT_FALSE(slider_delegate.created_front_layer());
    277     EXPECT_FALSE(slider_delegate.slide_completed());
    278     EXPECT_FALSE(slider_delegate.slider_destroyed());
    279     slider_delegate.Reset();
    280   }
    281   window.reset();
    282   EXPECT_TRUE(slider_delegate.slider_destroyed());
    283 }
    284 
    285 // Tests that the slide works correctly when the owner of the window changes
    286 // during the duration of the slide.
    287 TEST_F(WindowSliderTest, OwnerWindowChangesDuringWindowSlide) {
    288   scoped_ptr<aura::Window> parent(CreateNormalWindow(0, root_window(), NULL));
    289 
    290   NoEventWindowDelegate window_delegate;
    291   window_delegate.set_window_component(HTNOWHERE);
    292   scoped_ptr<aura::Window> window(CreateNormalWindow(1, parent.get(),
    293                                                      &window_delegate));
    294 
    295   WindowSliderDelegateTest slider_delegate;
    296   scoped_ptr<WindowSlider> slider(
    297       new WindowSlider(&slider_delegate, parent.get(), window.get()));
    298 
    299   // Generate a horizontal scroll, and change the owner in the middle of the
    300   // scroll.
    301   aura::test::EventGenerator generator(root_window());
    302   aura::Window* old_window = window.get();
    303   generator.GestureScrollSequenceWithCallback(
    304       gfx::Point(10, 10),
    305       gfx::Point(80, 10),
    306       base::TimeDelta::FromMilliseconds(10),
    307       1,
    308       base::Bind(&ChangeSliderOwnerDuringScrollCallback,
    309                  base::Unretained(&window),
    310                  slider.get()));
    311   aura::Window* new_window = window.get();
    312   EXPECT_NE(old_window, new_window);
    313 
    314   EXPECT_TRUE(slider_delegate.created_back_layer());
    315   EXPECT_TRUE(slider_delegate.slide_completed());
    316   EXPECT_FALSE(slider_delegate.created_front_layer());
    317   EXPECT_FALSE(slider_delegate.slide_aborted());
    318   EXPECT_FALSE(slider_delegate.slider_destroyed());
    319 }
    320 
    321 TEST_F(WindowSliderTest, NoSlideWhenLayerCantBeCreated) {
    322   scoped_ptr<aura::Window> window(CreateNormalWindow(0, root_window(), NULL));
    323   window->SetBounds(gfx::Rect(0, 0, 400, 400));
    324   WindowSliderDelegateTest slider_delegate;
    325   slider_delegate.SetCanCreateLayer(false);
    326 
    327   aura::test::EventGenerator generator(root_window());
    328 
    329   // Generate a horizontal overscroll.
    330   scoped_ptr<WindowSlider> slider(
    331       new WindowSlider(&slider_delegate, root_window(), window.get()));
    332   generator.GestureScrollSequence(gfx::Point(10, 10),
    333                                   gfx::Point(160, 10),
    334                                   base::TimeDelta::FromMilliseconds(10),
    335                                   10);
    336   EXPECT_FALSE(slider_delegate.created_back_layer());
    337   EXPECT_FALSE(slider_delegate.slide_completed());
    338   EXPECT_FALSE(slider_delegate.created_front_layer());
    339   EXPECT_FALSE(slider_delegate.slide_aborted());
    340   EXPECT_FALSE(slider_delegate.slider_destroyed());
    341   window->SetTransform(gfx::Transform());
    342 
    343   slider_delegate.SetCanCreateLayer(true);
    344   generator.GestureScrollSequence(gfx::Point(10, 10),
    345                                   gfx::Point(160, 10),
    346                                   base::TimeDelta::FromMilliseconds(10),
    347                                   10);
    348   EXPECT_TRUE(slider_delegate.created_back_layer());
    349   EXPECT_TRUE(slider_delegate.slide_completed());
    350   EXPECT_FALSE(slider_delegate.created_front_layer());
    351   EXPECT_FALSE(slider_delegate.slide_aborted());
    352   EXPECT_FALSE(slider_delegate.slider_destroyed());
    353 }
    354 
    355 // Tests that the owner window can be destroyed from |OnWindowSliderDestroyed()|
    356 // delegate callback without causing a crash.
    357 TEST_F(WindowSliderTest, OwnerIsDestroyedOnSliderDestroy) {
    358   size_t child_windows = root_window()->children().size();
    359   aura::Window* window = CreateNormalWindow(0, root_window(), NULL);
    360   window->SetBounds(gfx::Rect(0, 0, 400, 400));
    361   EXPECT_EQ(child_windows + 1, root_window()->children().size());
    362 
    363   WindowSliderDeleteOwnerOnDestroy slider_delegate(window);
    364   aura::test::EventGenerator generator(root_window());
    365 
    366   // Generate a horizontal overscroll.
    367   scoped_ptr<WindowSlider> slider(
    368       new WindowSlider(&slider_delegate, root_window(), window));
    369   generator.GestureScrollSequence(gfx::Point(10, 10),
    370                                   gfx::Point(160, 10),
    371                                   base::TimeDelta::FromMilliseconds(10),
    372                                   10);
    373   EXPECT_TRUE(slider_delegate.created_back_layer());
    374   EXPECT_TRUE(slider_delegate.slide_completed());
    375   EXPECT_FALSE(slider_delegate.created_front_layer());
    376   EXPECT_FALSE(slider_delegate.slide_aborted());
    377   EXPECT_FALSE(slider_delegate.slider_destroyed());
    378 
    379   slider.reset();
    380   // Destroying the slider would have destroyed |window| too. So |window| should
    381   // not need to be destroyed here.
    382   EXPECT_EQ(child_windows, root_window()->children().size());
    383 }
    384 
    385 // Tests that the owner window can be destroyed from |OnWindowSlideComplete()|
    386 // delegate callback without causing a crash.
    387 TEST_F(WindowSliderTest, OwnerIsDestroyedOnSlideComplete) {
    388   size_t child_windows = root_window()->children().size();
    389   aura::Window* window = CreateNormalWindow(0, root_window(), NULL);
    390   window->SetBounds(gfx::Rect(0, 0, 400, 400));
    391   EXPECT_EQ(child_windows + 1, root_window()->children().size());
    392 
    393   WindowSliderDeleteOwnerOnComplete slider_delegate(window);
    394   aura::test::EventGenerator generator(root_window());
    395 
    396   // Generate a horizontal overscroll.
    397   new WindowSlider(&slider_delegate, root_window(), window);
    398   generator.GestureScrollSequence(gfx::Point(10, 10),
    399                                   gfx::Point(160, 10),
    400                                   base::TimeDelta::FromMilliseconds(10),
    401                                   10);
    402   EXPECT_TRUE(slider_delegate.created_back_layer());
    403   EXPECT_TRUE(slider_delegate.slide_completed());
    404   EXPECT_FALSE(slider_delegate.created_front_layer());
    405   EXPECT_FALSE(slider_delegate.slide_aborted());
    406   EXPECT_TRUE(slider_delegate.slider_destroyed());
    407 
    408   // Destroying the slider would have destroyed |window| too. So |window| should
    409   // not need to be destroyed here.
    410   EXPECT_EQ(child_windows, root_window()->children().size());
    411 }
    412 
    413 }  // namespace content
    414