Remove stl_util's deletion function use from ui/.

ui/events/ozone/evdev/input_device_factory_evdev.cc

 // Copyright 2015 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/ozone/evdev/input_device_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
-#include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
@@ skipping 129 matching lines @@
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       cursor_(cursor),
 #if defined(USE_EVDEV_GESTURES)
       gesture_property_provider_(new GesturePropertyProvider),
 #endif
       dispatcher_(std::move(dispatcher)),
       weak_ptr_factory_(this) {
 }
 
 InputDeviceFactoryEvdev::~InputDeviceFactoryEvdev() {
-  base::STLDeleteValues(&converters_);
 }
 
 void InputDeviceFactoryEvdev::AddInputDevice(int id,
                                              const base::FilePath& path) {
   OpenInputDeviceParams params;
   params.id = id;
   params.path = path;
   params.cursor = cursor_;
   params.dispatcher = dispatcher_.get();
 
@@ skipping 34 matching lines @@
       DetachInputDevice(path);
 
     if (converter->type() == InputDeviceType::INPUT_DEVICE_INTERNAL &&
         converter->HasPen()) {
       converter->SetPalmSuppressionCallback(
           base::Bind(&InputDeviceFactoryEvdev::EnablePalmSuppression,
                      base::Unretained(this)));
     }
 
     // Add initialized device to map.
-    converters_[path] = converter.release();
+    converters_[path] = std::move(converter);
     converters_[path]->Start();
-    UpdateDirtyFlags(converters_[path]);
+    UpdateDirtyFlags(converters_[path].get());
 
     // Sync settings to new device.
     ApplyInputDeviceSettings();
     ApplyCapsLockLed();
   }
 
   --pending_device_changes_;
   NotifyDevicesUpdated();
 }
 
 void InputDeviceFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("evdev", "DetachInputDevice", "path", path.value());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // Remove device from map.
-  std::unique_ptr<EventConverterEvdev> converter(converters_[path]);
+  std::unique_ptr<EventConverterEvdev> converter = std::move(converters_[path]);
   converters_.erase(path);
 
   if (converter) {
     // Disable the device (to release keys/buttons/etc).
     converter->SetEnabled(false);
 
     // Cancel libevent notifications from this converter.
     converter->Stop();
 
     UpdateDirtyFlags(converter.get());
@@ skipping 58 matching lines @@
 
   SetIntPropertyForOneType(DT_MOUSE, "Pointer Sensitivity",
                            input_device_settings_.mouse_sensitivity);
   SetIntPropertyForOneType(DT_MOUSE, "Scroll Sensitivity",
                            input_device_settings_.mouse_sensitivity);
 
   SetBoolPropertyForOneType(DT_TOUCHPAD, "Tap Paused",
                             input_device_settings_.tap_to_click_paused);
 
   for (const auto& it : converters_) {
-    EventConverterEvdev* converter = it.second;
+    EventConverterEvdev* converter = it.second.get();
     converter->SetEnabled(IsDeviceEnabled(converter));
 
     if (converter->type() == InputDeviceType::INPUT_DEVICE_INTERNAL &&
         converter->HasKeyboard()) {
       converter->SetKeyFilter(
           input_device_settings_.enable_internal_keyboard_filter,
           input_device_settings_.internal_keyboard_allowed_keys);
     }
 
     converter->SetTouchEventLoggingEnabled(
         input_device_settings_.touch_event_logging_enabled);
   }
 }
 
 void InputDeviceFactoryEvdev::ApplyCapsLockLed() {
   for (const auto& it : converters_) {
-    EventConverterEvdev* converter = it.second;
+    EventConverterEvdev* converter = it.second.get();
     converter->SetCapsLockLed(caps_lock_led_enabled_);
   }
 }
 
 bool InputDeviceFactoryEvdev::IsDeviceEnabled(
     const EventConverterEvdev* converter) {
   if (!input_device_settings_.enable_internal_touchpad &&
       converter->type() == InputDeviceType::INPUT_DEVICE_INTERNAL &&
       converter->HasTouchpad())
     return false;
@@ skipping 124 matching lines @@
   }
 #endif
 }
 
 void InputDeviceFactoryEvdev::EnablePalmSuppression(bool enabled) {
   if (enabled == palm_suppression_enabled_)
     return;
   palm_suppression_enabled_ = enabled;
 
   for (const auto& it : converters_) {
-    it.second->SetEnabled(IsDeviceEnabled(it.second));
+    it.second->SetEnabled(IsDeviceEnabled(it.second.get()));
   }
 }
 
 }  // namespace ui