aura: Dispatch touch-events targetted to the root-window properly.

ui/aura/root_window_unittest.cc

 // Copyright (c) 2012 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/root_window.h"
 
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/event_client.h"
@@ skipping 51 matching lines @@
   gfx::Point mouse_event_location_;
   int mouse_event_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(NonClientDelegate);
 };
 
 // A simple EventFilter that keeps track of the number of key events that it's
 // seen.
 class EventCountFilter : public EventFilter {
  public:
-  EventCountFilter() : num_key_events_(0), num_mouse_events_(0) {}
+  EventCountFilter()
+      : num_key_events_(0),
+        num_mouse_events_(0),
+        num_touch_events_(0) {
+  }
   virtual ~EventCountFilter() {}
 
   int num_key_events() const { return num_key_events_; }
   int num_mouse_events() const { return num_mouse_events_; }
+  int num_touch_events() const { return num_touch_events_; }
 
   void Reset() {
     num_key_events_ = 0;
     num_mouse_events_ = 0;
   }
 
   // EventFilter overrides:
   virtual bool PreHandleKeyEvent(Window* target, ui::KeyEvent* event) OVERRIDE {
     num_key_events_++;
     return true;
   }
   virtual bool PreHandleMouseEvent(Window* target,
                                    ui::MouseEvent* event) OVERRIDE {
     num_mouse_events_++;
     return true;
   }
   virtual ui::TouchStatus PreHandleTouchEvent(
       Window* target, ui::TouchEvent* event) OVERRIDE {
+    num_touch_events_++;
     return ui::TOUCH_STATUS_UNKNOWN;
   }
   virtual ui::GestureStatus PreHandleGestureEvent(
       Window* target, ui::GestureEvent* event) OVERRIDE {
     return ui::GESTURE_STATUS_UNKNOWN;
   }
 
  private:
   // How many key events have been received?
   int num_key_events_;
 
   // How many mouse events have been received?
   int num_mouse_events_;
 
+  int num_touch_events_;
+
   DISALLOW_COPY_AND_ASSIGN(EventCountFilter);
 };
 
 }  // namespace
 
 typedef test::AuraTestBase RootWindowTest;
 
 TEST_F(RootWindowTest, OnHostMouseEvent) {
   // Create two non-overlapping windows so we don't have to worry about which
   // is on top.
@@ skipping 219 matching lines @@
   EXPECT_FALSE(root_window()->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &unknown_event));
   EXPECT_EQ(0, filter->num_key_events());
 
   ui::KeyEvent known_event(ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
   EXPECT_TRUE(root_window()->AsRootWindowHostDelegate()->OnHostKeyEvent(
       &known_event));
   EXPECT_EQ(1, filter->num_key_events());
 }
 
+// Tests that touch-events that are beyond the bounds of the root-window do get
+// propagated to the event filters correctly with the root as the target.
+TEST_F(RootWindowTest, TouchEventsOutsideBounds) {
+  EventCountFilter* filter = new EventCountFilter;
+  root_window()->SetEventFilter(filter);  // passes ownership
+
+  gfx::Point position = root_window()->bounds().origin();
+  position.Offset(-10, -10);
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, position, 0, base::TimeDelta());
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
+  EXPECT_EQ(1, filter->num_touch_events());
+
+  position = root_window()->bounds().origin();
+  position.Offset(root_window()->bounds().width() + 10,
+                  root_window()->bounds().height() + 10);
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, position, 0, base::TimeDelta());
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
+  EXPECT_EQ(2, filter->num_touch_events());
+}
+
 namespace {
 
 // FilterFilter that tracks the types of events it's seen.
 class EventFilterRecorder : public EventFilter {
  public:
   typedef std::vector<ui::EventType> Events;
 
   EventFilterRecorder() {}
 
   Events& events() { return events_; }
@@ skipping 180 matching lines @@
   root_window()->ReleaseMouseMoves();
   root_window()->AsRootWindowHostDelegate()->OnHostMouseEvent(
       &mouse_dragged_event2);
   EXPECT_EQ("MOUSE_DRAGGED", EventTypesToString(filter->events()));
   filter->events().clear();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
 }
 
 }  // namespace aura