Don't send touch events to windows like menus when the touch occurs outside the menu bounds.

ui/aura/window_event_dispatcher_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/window_event_dispatcher.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 124 matching lines @@
   // Mouse event was received by target window.
   EXPECT_EQ(1, delegate1->mouse_event_count());
   EXPECT_EQ(0, delegate2->mouse_event_count());
   // Event was in local coordinates.
   EXPECT_EQ(gfx::Point(1, 1), delegate1->mouse_event_location());
   // Non-client flag was set.
   EXPECT_TRUE(delegate1->mouse_event_flags() & ui::EF_IS_NON_CLIENT);
 }
 
 TEST_F(WindowEventDispatcherTest, RepostEvent) {
-  // Test RepostEvent in RootWindow. It only works for Mouse Press.
+  // Test RepostEvent in RootWindow. It only works for Mouse Press and touch
+  // press.
   EXPECT_FALSE(Env::GetInstance()->IsMouseButtonDown());
   gfx::Point point(10, 10);
   ui::MouseEvent event(ui::ET_MOUSE_PRESSED, point, point,
                        ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                        ui::EF_LEFT_MOUSE_BUTTON);
-  host()->dispatcher()->RepostEvent(event);
+  host()->dispatcher()->RepostEvent(&event);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(Env::GetInstance()->IsMouseButtonDown());
+
+  ui::TouchEvent touch_pressed_event(
+    ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, ui::EventTimeForNow());
+  host()->dispatcher()->RepostEvent(&touch_pressed_event);
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(Env::GetInstance()->is_touch_down());
 }
 
 // Check that we correctly track the state of the mouse buttons in response to
 // button press and release events.
 TEST_F(WindowEventDispatcherTest, MouseButtonState) {
   EXPECT_FALSE(Env::GetInstance()->IsMouseButtonDown());
 
   gfx::Point location;
   scoped_ptr<ui::MouseEvent> event;
 
@@ skipping 463 matching lines @@
   // capture).
   EXPECT_FALSE(Env::GetInstance()->IsMouseButtonDown());
   EventFilterRecorder recorder;
   scoped_ptr<Window> window(CreateNormalWindow(1, root_window(), NULL));
   window->SetBounds(gfx::Rect(20, 20, 40, 30));
   window->AddPreTargetHandler(&recorder);
   window->SetCapture();
   const ui::MouseEvent press_event(
       ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), ui::EventTimeForNow(),
       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
-  host()->dispatcher()->RepostEvent(press_event);
+  host()->dispatcher()->RepostEvent(&press_event);
   RunAllPendingInMessageLoop();  // Necessitated by RepostEvent().
   // Mouse moves/enters may be generated. We only care about a pressed.
   EXPECT_TRUE(EventTypesToString(recorder.events()).find("MOUSE_PRESSED") !=
               std::string::npos) << EventTypesToString(recorder.events());
 }
 
 TEST_F(WindowEventDispatcherTest, MouseMovesHeld) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
 
@@ skipping 764 matching lines @@
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
 
   ui::GestureEventDetails details(ui::ET_GESTURE_TAP_DOWN);
   gfx::Point point(10, 10);
   ui::GestureEvent event(point.x(),
                          point.y(),
                          0,
                          ui::EventTimeForNow(),
                          details);
-  host()->dispatcher()->RepostEvent(event);
+  host()->dispatcher()->RepostEvent(&event);
   RunAllPendingInMessageLoop();
   // TODO(rbyers): Currently disabled - crbug.com/170987
   EXPECT_FALSE(EventTypesToString(recorder.events()).find("GESTURE_TAP_DOWN") !=
               std::string::npos);
   recorder.Reset();
   root_window()->RemovePreTargetHandler(&recorder);
 }
 
 // This class inherits from the EventFilterRecorder class which provides a
 // facility to record events. This class additionally provides a facility to
@@ skipping 17 matching lines @@
     }
     EventFilterRecorder::OnTouchEvent(event);
   }
 
   void OnGestureEvent(ui::GestureEvent* event) override {
     EXPECT_EQ(done_cleanup_ ? repost_target_ : repost_source_, event->target());
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       if (!reposted_) {
         EXPECT_NE(repost_target_, event->target());
         reposted_ = true;
-        repost_target_->GetHost()->dispatcher()->RepostEvent(*event);
+        repost_target_->GetHost()->dispatcher()->RepostEvent(event);
         // Ensure that the reposted gesture event above goes to the
         // repost_target_;
         repost_source_->GetRootWindow()->RemoveChild(repost_source_);
         return;
       }
     }
     EventFilterRecorder::OnGestureEvent(event);
   }
 
   // Ignore mouse events as they don't fire at all times. This causes
@@ skipping 242 matching lines @@
 
   int mouse_event_count() const { return mouse_event_count_; }
 
   // TestWindowDelegate:
   void OnMouseEvent(ui::MouseEvent* event) override {
     if ((event->flags() & ui::EF_SHIFT_DOWN) != 0 &&
         mouse_event_count_++ == 0) {
       ui::MouseEvent mouse_event(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                                  gfx::Point(10, 10), ui::EventTimeForNow(),
                                  ui::EF_SHIFT_DOWN, 0);
-      root_->GetHost()->dispatcher()->RepostEvent(mouse_event);
+      root_->GetHost()->dispatcher()->RepostEvent(&mouse_event);
     }
   }
 
  private:
   Window* root_;
   int mouse_event_count_;
 
   DISALLOW_COPY_AND_ASSIGN(DontResetHeldEventWindowDelegate);
 };
 
 }  // namespace
 
 // Verifies RootWindow doesn't reset |RootWindow::held_repostable_event_| after
 // dispatching. This is done by using DontResetHeldEventWindowDelegate, which
 // tracks the number of events with ui::EF_SHIFT_DOWN set (all reposted events
 // have EF_SHIFT_DOWN). When the first event is seen RepostEvent() is used to
 // schedule another reposted event.
 TEST_F(WindowEventDispatcherTest, DontResetHeldEvent) {
   DontResetHeldEventWindowDelegate delegate(root_window());
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), &delegate));
   w1->SetBounds(gfx::Rect(0, 0, 40, 40));
   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                          gfx::Point(10, 10), ui::EventTimeForNow(),
                          ui::EF_SHIFT_DOWN, 0);
-  root_window()->GetHost()->dispatcher()->RepostEvent(pressed);
+  root_window()->GetHost()->dispatcher()->RepostEvent(&pressed);
   ui::MouseEvent pressed2(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                           gfx::Point(10, 10), ui::EventTimeForNow(), 0, 0);
   // Dispatch an event to flush event scheduled by way of RepostEvent().
   DispatchEventUsingWindowDispatcher(&pressed2);
   // Delegate should have seen reposted event (identified by way of
   // EF_SHIFT_DOWN). Dispatch another event to flush the second
   // RepostedEvent().
   EXPECT_EQ(1, delegate.mouse_event_count());
   DispatchEventUsingWindowDispatcher(&pressed2);
   EXPECT_EQ(2, delegate.mouse_event_count());
@@ skipping 40 matching lines @@
   // Should be deleted by |delegate|.
   WindowTreeHost* h2 = WindowTreeHost::Create(gfx::Rect(0, 0, 100, 100));
   h2->InitHost();
   DeleteHostFromHeldMouseEventDelegate delegate(h2);
   // Owned by |h2|.
   Window* w1 = CreateNormalWindow(1, h2->window(), &delegate);
   w1->SetBounds(gfx::Rect(0, 0, 40, 40));
   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                          gfx::Point(10, 10), ui::EventTimeForNow(),
                          ui::EF_SHIFT_DOWN, 0);
-  h2->dispatcher()->RepostEvent(pressed);
+  h2->dispatcher()->RepostEvent(&pressed);
   // RunAllPendingInMessageLoop() to make sure the |pressed| is run.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(delegate.got_mouse_event());
   EXPECT_TRUE(delegate.got_destroy());
 }
 
 TEST_F(WindowEventDispatcherTest, WindowHideCancelsActiveTouches) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
 
@@ skipping 219 matching lines @@
 
   void TearDown() override {
     window_.reset();
     WindowEventDispatcherTest::TearDown();
   }
 
  private:
   // Used to avoid a copying |event| when binding to a closure.
   static void RepostEventHelper(WindowEventDispatcher* dispatcher,
                                 scoped_ptr<ui::MouseEvent> event) {
-    dispatcher->RepostEvent(*event);
+    dispatcher->RepostEvent(event.get());
   }
 
   scoped_ptr<Window> window_;
   ExitMessageLoopOnMousePress handler_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowEventDispatcherTestWithMessageLoop);
 };
 
 TEST_F(WindowEventDispatcherTestWithMessageLoop, EventRepostedInNonNestedLoop) {
   CHECK(!message_loop()->is_running());
@@ skipping 140 matching lines @@
   const base::Closure callback_on_right_click = base::Bind(
       base::IgnoreResult(&WindowEventDispatcherTestInHighDPI::DispatchEvent),
       base::Unretained(this), base::Unretained(&mouse_move));
   TriggerNestedLoopOnRightMousePress handler(callback_on_right_click);
   window->AddPreTargetHandler(&handler);
 
   scoped_ptr<ui::MouseEvent> mouse(
       new ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                          gfx::Point(10, 10), ui::EventTimeForNow(),
                          ui::EF_RIGHT_MOUSE_BUTTON, ui::EF_RIGHT_MOUSE_BUTTON));
-  host()->dispatcher()->RepostEvent(*mouse);
+  host()->dispatcher()->RepostEvent(mouse.get());
   EXPECT_EQ(0, handler.num_mouse_events());
 
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
   // The window should receive the mouse-press and the mouse-move events.
   EXPECT_EQ(2, handler.num_mouse_events());
   // The mouse-move event location should be transformed because of the DSF
   // before it reaches the window.
   EXPECT_EQ(gfx::Point(40, 40).ToString(),
             handler.mouse_move_location().ToString());
@@ skipping 437 matching lines @@
   // 2x. A ET_MOUSE_EXITED event should have been sent to |w|.
   test_screen()->SetDeviceScaleFactor(2.f);
   dispatcher->OnCursorMovedToRootLocation(gfx::Point(11, 11));
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_MOUSE_EXITED));
 
   w->RemovePreTargetHandler(&recorder);
 }
 
 }  // namespace aura