Move |ScopedWebInputEvent| and |WebInputEventTraits| from |content::| to "ui/events/blink"

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 "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
 EventWithDispatchType::EventWithDispatchType(
-    ScopedWebInputEvent event,
+    ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType dispatch_type)
     : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
       dispatch_type_(dispatch_type) {}
 
 EventWithDispatchType::~EventWithDispatchType() {}
 
 bool EventWithDispatchType::CanCoalesceWith(
     const EventWithDispatchType& other) const {
   return other.dispatch_type_ == dispatch_type_ &&
          ScopedWebInputEventWithLatencyInfo::CanCoalesceWith(other);
 }
 
 void EventWithDispatchType::CoalesceWith(const EventWithDispatchType& other) {
   // If we are blocking and are coalescing touch, make sure to keep
   // the touch ids that need to be acked.
   if (dispatch_type_ == DISPATCH_TYPE_BLOCKING) {
     // We should only have blocking touch events that need coalescing.
     eventsToAck_.push_back(
-        WebInputEventTraits::GetUniqueTouchEventId(other.event()));
+        ui::WebInputEventTraits::GetUniqueTouchEventId(other.event()));
   }
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
 }
 
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
     : routing_id_(routing_id),
       client_(client),
       is_flinging_(false),
       main_task_runner_(main_task_runner) {}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
-    ScopedWebInputEvent event,
+    ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
   DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
          ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   bool non_blocking = original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING ||
                       ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING;
@@ skipping 75 matching lines @@
     base::AutoLock lock(event_queue_lock_);
     size_t size_before = events_.size();
     events_.Queue(std::move(event));
     send_notification = events_.size() != size_before;
   }
   if (send_notification)
     SendEventNotificationToMainThread();
 }
 
 }  // namespace content