Remove stl_util's deletion function use from content/.

content/browser/renderer_host/input/touch_event_queue.cc

 // Copyright 2013 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/input/touch_event_queue.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "ui/gfx/geometry/point_f.h"
 
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using ui::LatencyInfo;
 
@@ skipping 231 matching lines @@
   }
 
   base::TimeDelta GetTimeoutDelay() const {
     return use_mobile_timeout_ ? mobile_timeout_delay_ : desktop_timeout_delay_;
   }
 
   bool HasTimeoutEvent() const {
     return pending_ack_state_ != PENDING_ACK_NONE;
   }
 
-
   TouchEventQueue* touch_queue_;
 
   // How long to wait on a touch ack before cancelling the touch sequence.
   const base::TimeDelta desktop_timeout_delay_;
   const base::TimeDelta mobile_timeout_delay_;
   bool use_mobile_timeout_;
 
   // The touch event source for which we expect the next ack.
   PendingAckState pending_ack_state_;
 
@@ skipping 169 matching lines @@
   DCHECK(client);
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this,
                                 config.desktop_touch_ack_timeout_delay,
                                 config.mobile_touch_ack_timeout_delay));
   }
 }
 
 TouchEventQueue::~TouchEventQueue() {
-  if (!touch_queue_.empty())
-    base::STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");
 
   // If the queueing of |event| was triggered by an ack dispatch, defer
   // processing the event until the dispatch has finished.
   if (touch_queue_.empty() && !dispatching_touch_ack_) {
     // Optimization of the case without touch handlers.  Removing this path
     // yields identical results, but this avoids unnecessary allocations.
     PreFilterResult filter_result = FilterBeforeForwarding(event.event);
     if (filter_result != FORWARD_TO_RENDERER) {
       client_->OnFilteringTouchEvent(event.event);
       client_->OnTouchEventAck(event,
                                filter_result == ACK_WITH_NO_CONSUMER_EXISTS
                                    ? INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS
                                    : INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       return;
     }
 
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
-    touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
+    touch_queue_.push_back(
+        base::MakeUnique<CoalescedWebTouchEvent>(event, false));
     ForwardNextEventToRenderer();
     return;
   }
 
   // If the last queued touch-event was a touch-move, and the current event is
   // also a touch-move, then the events can be coalesced into a single event.
   if (touch_queue_.size() > 1) {
-    CoalescedWebTouchEvent* last_event = touch_queue_.back();
+    CoalescedWebTouchEvent* last_event = touch_queue_.back().get();
     if (last_event->CoalesceEventIfPossible(event))
       return;
   }
-  touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
+  touch_queue_.push_back(
+      base::MakeUnique<CoalescedWebTouchEvent>(event, false));
 }
 
 void TouchEventQueue::PrependTouchScrollNotification() {
   TRACE_EVENT0("input", "TouchEventQueue::PrependTouchScrollNotification");
 
   // The queue should have an in-flight event when this method is called because
   // this method is triggered by InputRouterImpl::SendGestureEvent, which is
   // triggered by TouchEventQueue::AckTouchEventToClient, which has just
   // received an ack for the in-flight event. We leave the head of the queue
   // untouched since it is the in-flight event.
   //
   // However, for the (integration) tests in RenderWidgetHostTest that trigger
   // this method indirectly, they push the TouchScrollStarted event into
   // TouchEventQueue without any way to dispatch it. Below we added a check for
   // non-empty queue to keep those tests as-is w/o exposing internals of this
   // class all the way up.
   if (!touch_queue_.empty()) {
     TouchEventWithLatencyInfo touch;
     touch.event.type = WebInputEvent::TouchScrollStarted;
     touch.event.uniqueTouchEventId = 0;
     touch.event.touchesLength = 0;
     touch.event.dispatchType = WebInputEvent::EventNonBlocking;
 
     auto it = touch_queue_.begin();
     DCHECK(it != touch_queue_.end());
-    touch_queue_.insert(++it, new CoalescedWebTouchEvent(touch, false));
+    touch_queue_.insert(++it,
+                        base::MakeUnique<CoalescedWebTouchEvent>(touch, false));
   }
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const LatencyInfo& latency_info,
                                       const uint32_t unique_touch_event_id) {
   TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
 
   // We receive an ack for async touchmove from render.
   if (!ack_pending_async_touchmove_ids_.empty() &&
@@ skipping 126 matching lines @@
     touch.event.dispatchType = WebInputEvent::EventNonBlocking;
 
   SendTouchEventImmediately(&touch);
 }
 
 void TouchEventQueue::FlushPendingAsyncTouchmove() {
   DCHECK(!dispatching_touch_);
   std::unique_ptr<TouchEventWithLatencyInfo> touch =
       std::move(pending_async_touchmove_);
   touch->event.dispatchType = WebInputEvent::EventNonBlocking;
-  touch_queue_.push_front(new CoalescedWebTouchEvent(*touch, true));
+  touch_queue_.push_front(
+      base::MakeUnique<CoalescedWebTouchEvent>(*touch, true));
   SendTouchEventImmediately(touch.get());
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
     if (has_handler_for_current_sequence_ &&
         !drop_remaining_touches_in_sequence_) {
       DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
           <<  "A touch handler should be offered a touchmove before scrolling.";
@@ skipping 89 matching lines @@
 }
 
 void TouchEventQueue::AckTouchEventToClient(
     InputEventAckState ack_result,
     const ui::LatencyInfo* optional_latency_info) {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty()) {
     NOTREACHED() << "Too many acks";
     return;
   }
-  std::unique_ptr<CoalescedWebTouchEvent> acked_event(touch_queue_.front());
+  std::unique_ptr<CoalescedWebTouchEvent> acked_event =
+      std::move(touch_queue_.front());
   DCHECK(acked_event);
 
   UpdateTouchConsumerStates(acked_event->coalesced_event().event, ack_result);
 
   // Note that acking the touch-event may result in multiple gestures being sent
   // to the renderer, or touch-events being queued.
   base::AutoReset<bool> dispatching_touch_ack(&dispatching_touch_ack_, true);
 
   // Skip ack for TouchScrollStarted since it was synthesized within the queue.
   if (acked_event->coalesced_event().event.type !=
@@ skipping 150 matching lines @@
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content