Get rid of the in_flight_event.

content/renderer/input/main_thread_event_queue.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 "content/renderer/input/main_thread_event_queue.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/input/event_with_latency_info.h"
@@ skipping 326 matching lines @@
     base::AutoLock lock(shared_state_lock_);
     shared_state_.events_.Queue(std::move(item));
     needs_post_task = !shared_state_.sent_post_task_;
     shared_state_.sent_post_task_ = true;
   }
 
   if (needs_post_task)
     PostTaskToMainThread();
 }
 
-void MainThreadEventQueue::DispatchInFlightEvent() {
-  if (in_flight_event_) {
-    in_flight_event_->Dispatch(this);
-    in_flight_event_.reset();
-  }
-}
-
 void MainThreadEventQueue::PossiblyScheduleMainFrame() {
   if (IsRafAlignedInputDisabled())
     return;
   bool needs_main_frame = false;
   {
     base::AutoLock lock(shared_state_lock_);
     if (!shared_state_.sent_main_frame_request_ &&
         !shared_state_.events_.empty() &&
         IsRafAlignedEvent(shared_state_.events_.front())) {
       needs_main_frame = true;
@@ skipping 15 matching lines @@
     events_to_process = shared_state_.events_.size();
 
     // Don't process rAF aligned events at tail of queue.
     while (events_to_process > 0 &&
            IsRafAlignedEvent(shared_state_.events_.at(events_to_process - 1))) {
       --events_to_process;
     }
   }
 
   while (events_to_process--) {
+    std::unique_ptr<MainThreadEventQueueTask> task;
     {
       base::AutoLock lock(shared_state_lock_);
       if (shared_state_.events_.empty())
         return;
-      in_flight_event_ = shared_state_.events_.Pop();
+      task = shared_state_.events_.Pop();
     }
 
     // Dispatching the event is outside of critical section.
-    DispatchInFlightEvent();
+    task->Dispatch(this);
   }
   PossiblyScheduleMainFrame();
 }
 
 static bool IsAsyncTouchMove(
     const std::unique_ptr<MainThreadEventQueueTask>& queued_item) {
   if (!queued_item->IsWebInputEvent())
     return false;
   const QueuedWebInputEvent* event =
       static_cast<const QueuedWebInputEvent*>(queued_item.get());
@@ skipping 12 matching lines @@
 
   // Record the queue size so that we only process
   // that maximum number of events.
   {
     base::AutoLock lock(shared_state_lock_);
     shared_state_.sent_main_frame_request_ = false;
     queue_size_at_start = shared_state_.events_.size();
   }
 
   while (queue_size_at_start--) {
+    std::unique_ptr<MainThreadEventQueueTask> task;
     {
       base::AutoLock lock(shared_state_lock_);
 
       if (shared_state_.events_.empty())
         return;
 
       if (IsRafAlignedEvent(shared_state_.events_.front())) {
         // Throttle touchmoves that are async.
         if (handle_raf_aligned_touch_input_ &&
             IsAsyncTouchMove(shared_state_.events_.front())) {
           if (shared_state_.events_.size() == 1 &&
               frame_time < shared_state_.last_async_touch_move_timestamp_ +
                                kAsyncTouchMoveInterval) {
             break;
           }
           shared_state_.last_async_touch_move_timestamp_ = frame_time;
         }
       }
-      in_flight_event_ = shared_state_.events_.Pop();
+      task = shared_state_.events_.Pop();
     }
-
     // Dispatching the event is outside of critical section.
-    DispatchInFlightEvent();
+    task->Dispatch(this);
   }
 
   PossiblyScheduleMainFrame();
 }
 
 void MainThreadEventQueue::PostTaskToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::DispatchEvents, this));
 }
 
@@ skipping 80 matching lines @@
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::SetNeedsMainFrame, this));
 }
 
 void MainThreadEventQueue::ClearClient() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_ = nullptr;
 }
 
 }  // namespace content