Keep track of coalesced events in main thread event queue

content/renderer/input/main_thread_event_queue_unittest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include <new>
 #include <utility>
 #include <vector>
 
@@ skipping 52 matching lines @@
     feature_list_.InitFromCommandLine(base::JoinString(features, ","),
                                       std::string());
   }
 
   void SetUp() override {
     queue_ = new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_,
                                       &renderer_scheduler_);
   }
 
   void HandleEventOnMainThread(int routing_id,
-                               const blink::WebInputEvent* event,
+                               const blink::WebCoalescedInputEvent* event,
                                const ui::LatencyInfo& latency,
                                InputEventDispatchType type) override {
     EXPECT_EQ(kTestRoutingID, routing_id);
-    handled_events_.push_back(ui::WebInputEventTraits::Clone(*event));
-    queue_->EventHandled(event->type(), INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    handled_events_.push_back(blink::WebCoalescedInputEvent(
+        event->event(), event->getCoalescedEventsPointers()));
+
+    queue_->EventHandled(event->event().type(),
+                         INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   }
 
   void SendInputEventAck(int routing_id,
                          blink::WebInputEvent::Type type,
                          InputEventAckState ack_result,
                          uint32_t touch_event_id) override {
     additional_acked_events_.push_back(touch_event_id);
   }
 
   bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) {
@@ skipping 29 matching lines @@
       needs_main_frame_ = false;
       queue_->DispatchRafAlignedInput();
     }
   }
 
  protected:
   base::test::ScopedFeatureList feature_list_;
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
-  std::vector<blink::WebScopedInputEvent> handled_events_;
+  std::vector<blink::WebCoalescedInputEvent> handled_events_;
+
   std::vector<uint32_t> additional_acked_events_;
   int raf_aligned_input_setting_;
   bool needs_main_frame_;
 };
 
 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
   base::HistogramTester histogram_tester;
 
   WebMouseWheelEvent kEvents[4] = {
       SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
   };
 
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
 
   for (WebMouseWheelEvent& event : kEvents)
     HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0,
             main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
+  for (const auto& coalesced_event : handled_events_) {
+    EXPECT_EQ(2u, coalesced_event.coalescedEventSize());
+  }
 
   {
-    EXPECT_EQ(kEvents[0].size(), handled_events_.at(0)->size());
-    EXPECT_EQ(kEvents[0].type(), handled_events_.at(0)->type());
+    EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size());
+    EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type());
     const WebMouseWheelEvent* last_wheel_event =
-        static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get());
+        static_cast<const WebMouseWheelEvent*>(
+            handled_events_.at(0).eventPointer());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
               last_wheel_event->dispatchType);
     WebMouseWheelEvent coalesced_event = kEvents[0];
     ui::Coalesce(kEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
 
   {
+    WebMouseWheelEvent coalesced_event = kEvents[0];
+    std::vector<const WebInputEvent*> coalesced_events =
+        handled_events_[0].getCoalescedEventsPointers();
+    const WebMouseWheelEvent* coalesced_wheel_event0 =
+        static_cast<const WebMouseWheelEvent*>(coalesced_events[0]);
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event0);
+
+    coalesced_event = kEvents[1];
+    const WebMouseWheelEvent* coalesced_wheel_event1 =
+        static_cast<const WebMouseWheelEvent*>(coalesced_events[1]);
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event1);
+  }
+
+  {
     const WebMouseWheelEvent* last_wheel_event =
-        static_cast<const WebMouseWheelEvent*>(handled_events_.at(1).get());
+        static_cast<const WebMouseWheelEvent*>(
+            handled_events_.at(1).eventPointer());
     WebMouseWheelEvent coalesced_event = kEvents[2];
     ui::Coalesce(kEvents[3], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
+
+  {
+    WebMouseWheelEvent coalesced_event = kEvents[2];
+    std::vector<const WebInputEvent*> coalesced_events =
+        handled_events_[1].getCoalescedEventsPointers();
+    const WebMouseWheelEvent* coalesced_wheel_event0 =
+        static_cast<const WebMouseWheelEvent*>(coalesced_events[0]);
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event0);
+
+    coalesced_event = kEvents[3];
+    const WebMouseWheelEvent* coalesced_wheel_event1 =
+        static_cast<const WebMouseWheelEvent*>(coalesced_events[1]);
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event1);
+  }
+
   histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 1, 2);
 }
 
 TEST_P(MainThreadEventQueueTest, NonBlockingTouch) {
   base::HistogramTester histogram_tester;
 
   SyntheticWebTouchEvent kEvents[4];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
   kEvents[1].setModifiers(1);
   kEvents[1].MovePoint(0, 20, 20);
   kEvents[2].PressPoint(10, 10);
   kEvents[2].MovePoint(0, 30, 30);
   kEvents[3].PressPoint(10, 10);
   kEvents[3].MovePoint(0, 35, 35);
 
   for (SyntheticWebTouchEvent& event : kEvents)
     HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(3u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
 
-  EXPECT_EQ(kEvents[0].size(), handled_events_.at(0)->size());
-  EXPECT_EQ(kEvents[0].type(), handled_events_.at(0)->type());
+  EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size());
+  EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type());
   const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer());
   kEvents[0].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(kEvents[0], *last_touch_event);
 
-  EXPECT_EQ(kEvents[1].size(), handled_events_.at(1)->size());
-  EXPECT_EQ(kEvents[1].type(), handled_events_.at(1)->type());
+  {
+    EXPECT_EQ(1u, handled_events_[0].coalescedEventSize());
+    const WebTouchEvent* coalesced_touch_event =
+        static_cast<const WebTouchEvent*>(
+            handled_events_[0].getCoalescedEventsPointers()[0]);
+    EXPECT_EQ(kEvents[0], *coalesced_touch_event);
+  }
+
+  EXPECT_EQ(kEvents[1].size(), handled_events_.at(1).event().size());
+  EXPECT_EQ(kEvents[1].type(), handled_events_.at(1).event().type());
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
   kEvents[1].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(kEvents[1], *last_touch_event);
 
-  EXPECT_EQ(kEvents[2].size(), handled_events_.at(1)->size());
-  EXPECT_EQ(kEvents[2].type(), handled_events_.at(2)->type());
+  {
+    EXPECT_EQ(1u, handled_events_[1].coalescedEventSize());
+    const WebTouchEvent* coalesced_touch_event =
+        static_cast<const WebTouchEvent*>(
+            handled_events_[1].getCoalescedEventsPointers()[0]);
+    EXPECT_EQ(kEvents[1], *coalesced_touch_event);
+  }
+
+  EXPECT_EQ(kEvents[2].size(), handled_events_.at(1).event().size());
+  EXPECT_EQ(kEvents[2].type(), handled_events_.at(2).event().type());
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer());
   WebTouchEvent coalesced_event = kEvents[2];
   ui::Coalesce(kEvents[3], &coalesced_event);
   coalesced_event.dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(coalesced_event, *last_touch_event);
+
+  {
+    EXPECT_EQ(2u, handled_events_[2].coalescedEventSize());
+    WebTouchEvent coalesced_event = kEvents[2];
+    std::vector<const WebInputEvent*> coalesced_events =
+        handled_events_[2].getCoalescedEventsPointers();
+    const WebTouchEvent* coalesced_touch_event0 =
+        static_cast<const WebTouchEvent*>(coalesced_events[0]);
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_touch_event0);
+
+    coalesced_event = kEvents[3];
+    const WebTouchEvent* coalesced_touch_event1 =
+        static_cast<const WebTouchEvent*>(coalesced_events[1]);
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_touch_event1);
+  }
+
   histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 0, 1);
   histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 1, 1);
 }
 
 TEST_P(MainThreadEventQueueTest, BlockingTouch) {
   base::HistogramTester histogram_tester;
   SyntheticWebTouchEvent kEvents[4];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
   kEvents[1].MovePoint(0, 20, 20);
@@ skipping 48 matching lines @@
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_EQ(raf_aligned_input_setting_ !=
                 (kRafAlignedEnabledMouse | kRafAlignedEnabledTouch),
             main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
   {
-    EXPECT_EQ(kWheelEvents[0].size(), handled_events_.at(0)->size());
-    EXPECT_EQ(kWheelEvents[0].type(), handled_events_.at(0)->type());
+    EXPECT_EQ(kWheelEvents[0].size(), handled_events_.at(0).event().size());
+    EXPECT_EQ(kWheelEvents[0].type(), handled_events_.at(0).event().type());
     const WebMouseWheelEvent* last_wheel_event =
-        static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get());
+        static_cast<const WebMouseWheelEvent*>(
+            handled_events_.at(0).eventPointer());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
               last_wheel_event->dispatchType);
     WebMouseWheelEvent coalesced_event = kWheelEvents[0];
     ui::Coalesce(kWheelEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
   {
-    EXPECT_EQ(kTouchEvents[0].size(), handled_events_.at(1)->size());
-    EXPECT_EQ(kTouchEvents[0].type(), handled_events_.at(1)->type());
+    EXPECT_EQ(kTouchEvents[0].size(), handled_events_.at(1).event().size());
+    EXPECT_EQ(kTouchEvents[0].type(), handled_events_.at(1).event().type());
     const WebTouchEvent* last_touch_event =
-        static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
+        static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
     WebTouchEvent coalesced_event = kTouchEvents[0];
     ui::Coalesce(kTouchEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_touch_event);
   }
 }
 
 TEST_P(MainThreadEventQueueTest, RafAlignedMouseInput) {
   // Don't run the test when we aren't supporting rAF aligned input.
@@ skipping 169 matching lines @@
   kEvents.PressPoint(10, 10);
   kEvents.touchStartOrFirstTouchMove = true;
   set_enable_fling_passive_listener_flag(true);
 
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(1u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(0)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(0)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type());
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
   const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer());
   kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.MovePoint(0, 30, 30);
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0,
             main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(1)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(1)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type());
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
   kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.MovePoint(0, 50, 50);
   kEvents.touchStartOrFirstTouchMove = false;
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(2)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(2)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.ReleasePoint(0);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(4u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(3)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(3)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(3).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(3).eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 }
 
 TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
   SyntheticWebTouchEvent kEvents;
   kEvents.PressPoint(10, 10);
   kEvents.touchStartOrFirstTouchMove = true;
   set_enable_fling_passive_listener_flag(false);
 
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(1u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(0)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(0)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   set_enable_fling_passive_listener_flag(false);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(1)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(1)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   set_enable_fling_passive_listener_flag(true);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(2)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(2)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.MovePoint(0, 30, 30);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(4u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(3)->size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(3)->type());
+  EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size());
+  EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(3).get());
+      static_cast<const WebTouchEvent*>(handled_events_.at(3).eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 }
 
 // The boolean parameterized test varies whether rAF aligned input
 // is enabled or not.
 INSTANTIATE_TEST_CASE_P(
     MainThreadEventQueueTests,
     MainThreadEventQueueTest,
     testing::Range(0u,
                    (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1));
 
 }  // namespace content