Remove stl_util's deletion function use from content/.

content/browser/renderer_host/input/mouse_wheel_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/browser/renderer_host/input/mouse_wheel_event_queue.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 "ui/events/blink/web_input_event_traits.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseWheelEvent;
 using ui::LatencyInfo;
 
 namespace content {
 
@@ skipping 20 matching lines @@
       needs_scroll_begin_(true),
       needs_scroll_end_(false),
       enable_scroll_latching_(enable_scroll_latching),
       scrolling_device_(blink::WebGestureDeviceUninitialized) {
   DCHECK(client);
   scroll_transaction_ms_ =
       enable_scroll_latching_ ? kDefaultWheelScrollLatchingTransactionMs : 0;
 }
 
 MouseWheelEventQueue::~MouseWheelEventQueue() {
-  if (!wheel_queue_.empty())
-    base::STLDeleteElements(&wheel_queue_);
 }
 
 void MouseWheelEventQueue::QueueEvent(
     const MouseWheelEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "MouseWheelEventQueue::QueueEvent");
 
   if (event_sent_for_gesture_ack_ && !wheel_queue_.empty()) {
-    QueuedWebMouseWheelEvent* last_event = wheel_queue_.back();
+    QueuedWebMouseWheelEvent* last_event = wheel_queue_.back().get();
     if (last_event->CanCoalesceWith(event)) {
       last_event->CoalesceWith(event);
       TRACE_EVENT_INSTANT2("input", "MouseWheelEventQueue::CoalescedWheelEvent",
                            TRACE_EVENT_SCOPE_THREAD, "total_dx",
                            last_event->event.deltaX, "total_dy",
                            last_event->event.deltaY);
       return;
     }
   }
 
-  wheel_queue_.push_back(new QueuedWebMouseWheelEvent(event));
+  wheel_queue_.push_back(base::MakeUnique<QueuedWebMouseWheelEvent>(event));
   TryForwardNextEventToRenderer();
   LOCAL_HISTOGRAM_COUNTS_100("Renderer.WheelQueueSize", wheel_queue_.size());
 }
 
 void MouseWheelEventQueue::ProcessMouseWheelAck(
     InputEventAckState ack_result,
     const LatencyInfo& latency_info) {
   TRACE_EVENT0("input", "MouseWheelEventQueue::ProcessMouseWheelAck");
   if (!event_sent_for_gesture_ack_)
     return;
@@ skipping 164 matching lines @@
       scroll_end_timer_.Reset();
   }
 }
 
 void MouseWheelEventQueue::TryForwardNextEventToRenderer() {
   TRACE_EVENT0("input", "MouseWheelEventQueue::TryForwardNextEventToRenderer");
 
   if (wheel_queue_.empty() || event_sent_for_gesture_ack_)
     return;
 
-  event_sent_for_gesture_ack_.reset(wheel_queue_.front());
+  event_sent_for_gesture_ack_ = std::move(wheel_queue_.front());
   wheel_queue_.pop_front();
 
   client_->SendMouseWheelEventImmediately(*event_sent_for_gesture_ack_);
 }
 
 void MouseWheelEventQueue::SendScrollEnd(WebGestureEvent update_event,
                                          bool synthetic) {
   DCHECK((synthetic && !needs_scroll_end_) || needs_scroll_end_);
 
   WebGestureEvent scroll_end(update_event);
@@ skipping 36 matching lines @@
   scroll_begin.data.scrollBegin.deltaHintUnits =
       gesture_update.data.scrollUpdate.deltaUnits;
 
   needs_scroll_begin_ = false;
   needs_scroll_end_ = true;
   client_->ForwardGestureEventWithLatencyInfo(
       scroll_begin, ui::LatencyInfo(ui::SourceEventType::WHEEL));
 }
 
 }  // namespace content