Always forward touch events to the TouchEventQueue

content/browser/renderer_host/render_widget_host_view_aura_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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 430 matching lines @@
 
   void SendInputEventACK(WebInputEvent::Type type,
       InputEventAckState ack_result) {
     InputHostMsg_HandleInputEvent_ACK_Params ack;
     ack.type = type;
     ack.state = ack_result;
     InputHostMsg_HandleInputEvent_ACK response(0, ack);
     widget_host_->OnMessageReceived(response);
   }
 
+  size_t GetSentMessageCountAndResetSink() {
+    size_t count = sink_->message_count();
+    sink_->ClearMessages();
+    return count;
+  }
+
+  void AckLastSentInputEventIfNecessary(InputEventAckState ack_result) {
+    if (!sink_->message_count())
+      return;
+
+    InputMsg_HandleInputEvent::Param params;
+    if (!InputMsg_HandleInputEvent::Read(
+            sink_->GetMessageAt(sink_->message_count() - 1), &params)) {
+      return;
+    }
+
+    if (WebInputEventTraits::IgnoresAckDisposition(*get<0>(params)))
+      return;
+
+    SendInputEventACK(get<0>(params)->type, ack_result);
+  }
+
  protected:
   // If true, then calls RWH::Shutdown() instead of deleting RWH.
   bool widget_host_uses_shutdown_to_destroy_;
 
   bool is_guest_view_hack_;
 
   base::MessageLoopForUI message_loop_;
   BrowserThreadImpl browser_thread_for_ui_;
   scoped_ptr<aura::test::AuraTestHelper> aura_test_helper_;
   scoped_ptr<BrowserContext> browser_context_;
@@ skipping 225 matching lines @@
   void MoveTouchPoint(int index, int x, int y) {
     touch_event_.MovePoint(index, x, y);
     SendTouchEvent();
   }
 
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
     SendTouchEvent();
   }
 
-  size_t GetSentMessageCountAndResetSink() {
-    size_t count = sink_->message_count();
-    sink_->ClearMessages();
-    return count;
-  }
-
-  void AckLastSentInputEventIfNecessary(InputEventAckState ack_result) {
-    if (!sink_->message_count())
-      return;
-
-    InputMsg_HandleInputEvent::Param params;
-    if (!InputMsg_HandleInputEvent::Read(
-            sink_->GetMessageAt(sink_->message_count() - 1), &params)) {
-      return;
-    }
-
-    if (WebInputEventTraits::IgnoresAckDisposition(*get<0>(params)))
-      return;
-
-    SendInputEventACK(get<0>(params)->type, ack_result);
-  }
-
   SyntheticWebTouchEvent touch_event_;
 
   scoped_ptr<TestOverscrollDelegate> overscroll_delegate_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraOverscrollTest);
 };
 
 class RenderWidgetHostViewAuraShutdownTest
     : public RenderWidgetHostViewAuraTest {
@@ skipping 286 matching lines @@
               sink_->GetMessageAt(0)->type());
     EXPECT_EQ(InputMsg_HandleInputEvent::ID,
               sink_->GetMessageAt(1)->type());
   }
 }
 
 // Checks that touch-event state is maintained correctly.
 TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) {
   view_->InitAsChild(NULL);
   view_->Show();
+  GetSentMessageCountAndResetSink();
 
   // Start with no touch-event handler in the renderer.
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
-  EXPECT_FALSE(widget_host_->ShouldForwardTouchEvent());
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                        gfx::Point(30, 30),
                        0,
                        ui::EventTimeForNow());
   ui::TouchEvent move(ui::ET_TOUCH_MOVED,
                       gfx::Point(20, 20),
                       0,
                       ui::EventTimeForNow());
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
                          gfx::Point(20, 20),
                          0,
                          ui::EventTimeForNow());
 
+  // The touch events should get forwared from the view, but they should not
+  // reach the renderer.
   view_->OnTouchEvent(&press);
-  EXPECT_FALSE(press.handled());
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_->type);
   EXPECT_TRUE(view_->touch_event_->cancelable);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StatePressed,
             view_->touch_event_->touches[0].state);
 
   view_->OnTouchEvent(&move);
-  EXPECT_FALSE(move.handled());
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_TRUE(view_->touch_event_->cancelable);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StateMoved,
             view_->touch_event_->touches[0].state);
 
   view_->OnTouchEvent(&release);
-  EXPECT_FALSE(release.handled());
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+  EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(nullptr, view_->touch_event_);
 
   // Now install some touch-event handlers and do the same steps. The touch
   // events should now be consumed. However, the touch-event state should be
   // updated as before.
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
-  EXPECT_TRUE(widget_host_->ShouldForwardTouchEvent());
 
   view_->OnTouchEvent(&press);
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_->type);
   EXPECT_TRUE(view_->touch_event_->cancelable);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StatePressed,
             view_->touch_event_->touches[0].state);
 
   view_->OnTouchEvent(&move);
   EXPECT_TRUE(move.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_TRUE(view_->touch_event_->cancelable);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StateMoved,
             view_->touch_event_->touches[0].state);
   view_->OnTouchEvent(&release);
   EXPECT_TRUE(release.synchronous_handling_disabled());
   EXPECT_EQ(nullptr, view_->touch_event_);
 
   // Now start a touch event, and remove the event-handlers before the release.
   view_->OnTouchEvent(&press);
   EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_->type);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StatePressed,
             view_->touch_event_->touches[0].state);
 
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
-  EXPECT_TRUE(widget_host_->ShouldForwardTouchEvent());
 
   // Ack'ing the outstanding event should flush the pending touch queue.
   InputHostMsg_HandleInputEvent_ACK_Params ack;
   ack.type = blink::WebInputEvent::TouchStart;
   ack.state = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   widget_host_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
-  EXPECT_FALSE(widget_host_->ShouldForwardTouchEvent());
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 0,
       base::Time::NowFromSystemTime() - base::Time());
   view_->OnTouchEvent(&move2);
-  EXPECT_FALSE(move2.handled());
+  EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StateMoved,
             view_->touch_event_->touches[0].state);
 
   ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0,
       base::Time::NowFromSystemTime() - base::Time());
   view_->OnTouchEvent(&release2);
-  EXPECT_FALSE(release2.handled());
+  EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(nullptr, view_->touch_event_);
 }
 
 // Checks that touch-events are queued properly when there is a touch-event
 // handler on the page.
 TEST_F(RenderWidgetHostViewAuraTest, TouchEventSyncAsync) {
   view_->InitAsChild(NULL);
   view_->Show();
 
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
-  EXPECT_TRUE(widget_host_->ShouldForwardTouchEvent());
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
                        gfx::Point(30, 30),
                        0,
                        ui::EventTimeForNow());
   ui::TouchEvent move(ui::ET_TOUCH_MOVED,
                       gfx::Point(20, 20),
                       0,
                       ui::EventTimeForNow());
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
@@ skipping 1956 matching lines @@
   TearDownEnvironment();
   ASSERT_FALSE(guest_view_weak_.get());
 }
 
 // Tests that invalid touch events are consumed and handled
 // synchronously.
 TEST_F(RenderWidgetHostViewAuraTest,
        InvalidEventsHaveSyncHandlingDisabled) {
   view_->InitAsChild(NULL);
   view_->Show();
+  GetSentMessageCountAndResetSink();
 
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
-  EXPECT_TRUE(widget_host_->ShouldForwardTouchEvent());
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0,
                        ui::EventTimeForNow());
 
   // Construct a move with a touch id which doesn't exist.
   ui::TouchEvent invalid_move(ui::ET_TOUCH_MOVED, gfx::Point(30, 30), 1,
                               ui::EventTimeForNow());
 
+  // Valid press is handled asynchronously.
   view_->OnTouchEvent(&press);
+  EXPECT_TRUE(press.synchronous_handling_disabled());
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+  AckLastSentInputEventIfNecessary(INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // Invalid move is handled synchronously, but is consumed. It should not
+  // be forwarded to the renderer.
   view_->OnTouchEvent(&invalid_move);
-  // Valid press is handled asynchronously.
-  EXPECT_TRUE(press.synchronous_handling_disabled());
-  // Invalid move is handled synchronously, but is consumed.
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_FALSE(invalid_move.synchronous_handling_disabled());
   EXPECT_TRUE(invalid_move.stopped_propagation());
 }
 
 // Checks key event codes.
 TEST_F(RenderWidgetHostViewAuraTest, KeyEvent) {
   view_->InitAsChild(NULL);
   view_->Show();
 
   ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::DomCode::KEY_A,
@@ skipping 78 matching lines @@
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(20, 20), 1, ui::EventTimeForNow());
   view_->OnTouchEvent(&press2);
   SendInputEventACK(blink::WebInputEvent::TouchStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(2U, view_->dispatcher_->processed_touch_event_count());
 }
 
 }  // namespace content