Remove ui/events/blink dependency on blink_minimal.

ui/events/blink/web_input_event_traits.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 "ui/events/blink/web_input_event_traits.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "third_party/WebKit/public/platform/WebGestureEvent.h"
 #include "third_party/WebKit/public/platform/WebKeyboardEvent.h"
@@ skipping 90 matching lines @@
   StringAppendF(result,
                 "{\n Touches: %u, DispatchType: %d, CausesScrolling: %d,"
                 " uniqueTouchEventId: %u\n[\n",
                 event.touchesLength, event.dispatchType,
                 event.movedBeyondSlopRegion, event.uniqueTouchEventId);
   for (unsigned i = 0; i < event.touchesLength; ++i)
     ApppendTouchPointDetails(event.touches[i], result);
   result->append(" ]\n}");
 }
 
+struct WebInputEventDelete {
+  template <class EventType>
+  bool Execute(WebInputEvent* event, void*) const {
+    if (!event)
+      return false;
+    DCHECK_EQ(sizeof(EventType), event->size());
+    delete static_cast<EventType*>(event);
+    return true;
+  }
+};
+
 struct WebInputEventToString {
   template <class EventType>
   bool Execute(const WebInputEvent& event, std::string* result) const {
     SStringPrintf(result, "%s (Time: %lf, Modifiers: %d)\n",
                   WebInputEvent::GetName(event.type()),
                   event.timeStampSeconds(), event.modifiers());
     const EventType& typed_event = static_cast<const EventType&>(event);
     ApppendEventDetails(typed_event, result);
     return true;
   }
 };
 
 struct WebInputEventSize {
   template <class EventType>
   bool Execute(WebInputEvent::Type /* type */, size_t* type_size) const {
     *type_size = sizeof(EventType);
     return true;
   }
 };
 
 struct WebInputEventClone {
   template <class EventType>
   bool Execute(const WebInputEvent& event,
-               blink::WebScopedInputEvent* scoped_event) const {
+               WebScopedInputEvent* scoped_event) const {
     DCHECK_EQ(sizeof(EventType), event.size());
-    *scoped_event = blink::WebScopedInputEvent(
+    *scoped_event = WebScopedInputEvent(
         new EventType(static_cast<const EventType&>(event)));
     return true;
   }
 };
 
 template <typename Operator, typename ArgIn, typename ArgOut>
 bool Apply(Operator op,
            WebInputEvent::Type type,
            const ArgIn& arg_in,
            ArgOut* arg_out) {
   if (WebInputEvent::isMouseEventType(type))
     return op.template Execute<WebMouseEvent>(arg_in, arg_out);
   else if (type == WebInputEvent::MouseWheel)
     return op.template Execute<WebMouseWheelEvent>(arg_in, arg_out);
   else if (WebInputEvent::isKeyboardEventType(type))
     return op.template Execute<WebKeyboardEvent>(arg_in, arg_out);
   else if (WebInputEvent::isTouchEventType(type))
     return op.template Execute<WebTouchEvent>(arg_in, arg_out);
   else if (WebInputEvent::isGestureEventType(type))
     return op.template Execute<WebGestureEvent>(arg_in, arg_out);
 
   NOTREACHED() << "Unknown webkit event type " << type;
   return false;
 }
 
 }  // namespace
 
+void WebInputEventDeleter::operator()(WebInputEvent* event) const {
+  if (!event)
+    return;
+  void* temp = nullptr;
+  Apply(WebInputEventDelete(), event->type(), event, temp);
+}
+
 std::string WebInputEventTraits::ToString(const WebInputEvent& event) {
   std::string result;
   Apply(WebInputEventToString(), event.type(), event, &result);
   return result;
 }
 
 size_t WebInputEventTraits::GetSize(WebInputEvent::Type type) {
   size_t size = 0;
   Apply(WebInputEventSize(), type, type, &size);
   return size;
 }
 
-blink::WebScopedInputEvent WebInputEventTraits::Clone(
-    const WebInputEvent& event) {
-  blink::WebScopedInputEvent scoped_event;
+WebScopedInputEvent WebInputEventTraits::Clone(const WebInputEvent& event) {
+  WebScopedInputEvent scoped_event;
   Apply(WebInputEventClone(), event.type(), event, &scoped_event);
   return scoped_event;
 }
 
 bool WebInputEventTraits::ShouldBlockEventStream(const WebInputEvent& event) {
   switch (event.type()) {
     case WebInputEvent::MouseDown:
     case WebInputEvent::MouseUp:
     case WebInputEvent::MouseEnter:
     case WebInputEvent::MouseLeave:
@@ skipping 58 matching lines @@
     source_event_type = SourceEventType::WHEEL;
   } else if (event.sourceDevice ==
              blink::WebGestureDevice::WebGestureDeviceTouchscreen) {
     source_event_type = SourceEventType::TOUCH;
   }
   LatencyInfo latency_info(source_event_type);
   return latency_info;
 }
 
 }  // namespace ui