Remove stl_util's deletion function use from ui/.

ui/events/gestures/gesture_recognizer_impl.cc

 // Copyright (c) 2012 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/gestures/gesture_recognizer_impl.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/gestures/gesture_types.h"
 
 namespace ui {
 
 namespace {
 
-template <typename T>
-void TransferConsumer(GestureConsumer* current_consumer,
-                      GestureConsumer* new_consumer,
-                      std::map<GestureConsumer*, T>* map) {
+void TransferConsumer(
+    GestureConsumer* current_consumer,
+    GestureConsumer* new_consumer,
+    std::map<GestureConsumer*, std::unique_ptr<GestureProviderAura>>* map) {
   if (map->count(current_consumer)) {
-    (*map)[new_consumer] = (*map)[current_consumer];
+    (*map)[new_consumer] = std::move((*map)[current_consumer]);
     (*map)[new_consumer]->set_gesture_consumer(new_consumer);
     map->erase(current_consumer);
   }
 }
 
 bool RemoveConsumerFromMap(GestureConsumer* consumer,
                            GestureRecognizerImpl::TouchIdToConsumerMap* map) {
   bool consumer_removed = false;
-  for (GestureRecognizerImpl::TouchIdToConsumerMap::iterator i = map->begin();
-       i != map->end();) {
+  for (auto i = map->begin(); i != map->end();) {
     if (i->second == consumer) {
       map->erase(i++);
       consumer_removed = true;
     } else {
       ++i;
     }
   }
   return consumer_removed;
 }
 
-GestureProviderAura* CreateGestureProvider(GestureConsumer* consumer,
-                                           GestureProviderAuraClient* client) {
-  return new GestureProviderAura(consumer, client);
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, public:
 
 GestureRecognizerImpl::GestureRecognizerImpl() {
 }
 
 GestureRecognizerImpl::~GestureRecognizerImpl() {
-  base::STLDeleteValues(&consumer_gesture_provider_);
 }
 
 // Checks if this finger is already down, if so, returns the current target.
 // Otherwise, returns NULL.
 GestureConsumer* GestureRecognizerImpl::GetTouchLockedTarget(
     const TouchEvent& event) {
   return touch_id_target_[event.touch_id()];
 }
 
 GestureConsumer* GestureRecognizerImpl::GetTargetForLocation(
     const gfx::PointF& location, int source_device_id) {
   const float max_distance =
       GestureConfiguration::GetInstance()
           ->max_separation_for_gesture_touches_in_pixels();
 
   gfx::PointF closest_point;
   int closest_touch_id = 0;
   double closest_distance_squared = std::numeric_limits<double>::infinity();
 
-  std::map<GestureConsumer*, GestureProviderAura*>::iterator i;
-  for (i = consumer_gesture_provider_.begin();
-       i != consumer_gesture_provider_.end();
-       ++i) {
-    const MotionEventAura& pointer_state = i->second->pointer_state();
+  for (const auto& provider_pair : consumer_gesture_provider_) {
+    const MotionEventAura& pointer_state =
+        provider_pair.second->pointer_state();
     for (size_t j = 0; j < pointer_state.GetPointerCount(); ++j) {
       if (source_device_id != pointer_state.GetSourceDeviceId(j))
         continue;
       gfx::PointF point(pointer_state.GetX(j), pointer_state.GetY(j));
       // Relative distance is all we need here, so LengthSquared() is
       // appropriate, and cheaper than Length().
       double distance_squared = (point - location).LengthSquared();
       if (distance_squared < closest_distance_squared) {
         closest_point = point;
         closest_touch_id = pointer_state.GetPointerId(j);
         closest_distance_squared = distance_squared;
       }
     }
   }
 
   if (closest_distance_squared < max_distance * max_distance)
     return touch_id_target_[closest_touch_id];
   return NULL;
 }
 
 void GestureRecognizerImpl::CancelActiveTouchesExcept(
     GestureConsumer* not_cancelled) {
   // Do not iterate directly over |consumer_gesture_provider_| because canceling
   // active touches may cause the consumer to be removed from
   // |consumer_gesture_provider_|. See crbug.com/651258 for more info.
   std::vector<GestureConsumer*> consumers(consumer_gesture_provider_.size());
-  for (auto entry : consumer_gesture_provider_) {
+  for (const auto& entry : consumer_gesture_provider_) {
     if (entry.first == not_cancelled)
       continue;
 
     consumers.push_back(entry.first);
   }
 
   for (auto consumer : consumers)
     CancelActiveTouches(consumer);
 }
 
@@ skipping 102 matching lines @@
   for (const std::unique_ptr<TouchEvent>& cancelling_touch : cancelling_touches)
     helper->DispatchSyntheticTouchEvent(cancelling_touch.get());
   return cancelling_touches.size() > 0U;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, private:
 
 GestureProviderAura* GestureRecognizerImpl::GetGestureProviderForConsumer(
     GestureConsumer* consumer) {
-  GestureProviderAura* gesture_provider = consumer_gesture_provider_[consumer];
+  GestureProviderAura* gesture_provider =
+      consumer_gesture_provider_[consumer].get();
   if (!gesture_provider) {
-    gesture_provider = CreateGestureProvider(consumer, this);
-    consumer_gesture_provider_[consumer] = gesture_provider;
+    gesture_provider = new GestureProviderAura(consumer, this);
+    consumer_gesture_provider_[consumer] = base::WrapUnique(gesture_provider);
   }
   return gesture_provider;
 }
 
 void GestureRecognizerImpl::SetupTargets(const TouchEvent& event,
                                          GestureConsumer* target) {
   if (event.type() == ui::ET_TOUCH_RELEASED ||
       event.type() == ui::ET_TOUCH_CANCELLED) {
     touch_id_target_.erase(event.touch_id());
   } else if (event.type() == ui::ET_TOUCH_PRESSED) {
@@ skipping 34 matching lines @@
   gesture_provider->OnTouchEventAck(unique_event_id, result != ER_UNHANDLED);
   return gesture_provider->GetAndResetPendingGestures();
 }
 
 bool GestureRecognizerImpl::CleanupStateForConsumer(
     GestureConsumer* consumer) {
   bool state_cleaned_up = false;
 
   if (consumer_gesture_provider_.count(consumer)) {
     state_cleaned_up = true;
-    delete consumer_gesture_provider_[consumer];
     consumer_gesture_provider_.erase(consumer);
   }
 
   state_cleaned_up |= RemoveConsumerFromMap(consumer, &touch_id_target_);
   return state_cleaned_up;
 }
 
 void GestureRecognizerImpl::AddGestureEventHelper(GestureEventHelper* helper) {
   helpers_.push_back(helper);
 }
@@ skipping 48 matching lines @@
   std::vector<GestureEventHelper*>::iterator it;
   for (it = helpers.begin(); it != helpers.end(); ++it)
     gesture_recognizer->AddGestureEventHelper(*it);
 
   helpers.clear();
   g_gesture_recognizer_instance =
       static_cast<GestureRecognizerImpl*>(gesture_recognizer);
 }
 
 }  // namespace ui