Fix memory leak in ~GestureRecognizerImpl

ui/base/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/base/gestures/gesture_recognizer_impl.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "ui/base/events.h"
@@ skipping 119 matching lines @@
 template <typename T>
 void TransferConsumer(GestureConsumer* current_consumer,
                       GestureConsumer* new_consumer,
                       std::map<GestureConsumer*, T>* map) {
   if (map->count(current_consumer)) {
     (*map)[new_consumer] = (*map)[current_consumer];
     map->erase(current_consumer);
   }
 }
 
+template <typename T>
+void TransferConsumer(GestureConsumer* current_consumer,
+                      GestureConsumer* new_consumer,
+                      std::map<GestureConsumer*, scoped_ptr<T>>* map) {
+  if (map->count(current_consumer)) {
+    (*map)[new_consumer].swap((*map)[current_consumer]);
+    map->erase(current_consumer);

[girard, 2012/08/02 17:14:20]

Partial template specialization (from generic TransferConsumer, above).

+  }
+}
+
 void RemoveConsumerFromMap(GestureConsumer* consumer,
                            GestureRecognizerImpl::TouchIdToConsumerMap* map) {
   for (GestureRecognizerImpl::TouchIdToConsumerMap::iterator i = map->begin();
        i != map->end();) {
     if (i->second == consumer)
       map->erase(i++);
     else
       ++i;
   }
 }
@@ skipping 34 matching lines @@
   GestureConsumer* target = NULL;
   int touch_id = event->GetLowestTouchId();
   target = touch_id_target_for_gestures_[touch_id];
   return target;
 }
 
 GestureConsumer* GestureRecognizerImpl::GetTargetForLocation(
     const gfx::Point& location) {
   const GesturePoint* closest_point = NULL;
   int closest_distance_squared = 0;
-  std::map<GestureConsumer*, GestureSequence*>::iterator i;
+  std::map<GestureConsumer*, scoped_ptr<GestureSequence>>::iterator i;
   for (i = consumer_sequence_.begin(); i != consumer_sequence_.end(); ++i) {
     const GesturePoint* points = i->second->points();
     for (int j = 0; j < GestureSequence::kMaxGesturePoints; ++j) {
       if (!points[j].in_use())
         continue;
       gfx::Point delta =
           points[j].last_touch_position().Subtract(location);
       int distance = delta.x() * delta.x() + delta.y() * delta.y();
       if (!closest_point || distance < closest_distance_squared) {
         closest_point = &points[j];
@@ skipping 56 matching lines @@
 GestureSequence* GestureRecognizerImpl::CreateSequence(
     GestureEventHelper* helper) {
   return new GestureSequence(helper);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureRecognizerImpl, private:
 
 GestureSequence* GestureRecognizerImpl::GetGestureSequenceForConsumer(
     GestureConsumer* consumer) {
-  GestureSequence* gesture_sequence = consumer_sequence_[consumer];
+  GestureSequence* gesture_sequence = consumer_sequence_[consumer].get();
   if (!gesture_sequence) {
     gesture_sequence = CreateSequence(helper_);
-    consumer_sequence_[consumer] = gesture_sequence;
+    consumer_sequence_[consumer].reset(gesture_sequence);
   }
   return gesture_sequence;
 }
 
 GestureSequence::Gestures* GestureRecognizerImpl::ProcessTouchEventForGesture(
     const TouchEvent& event,
     ui::TouchStatus status,
     GestureConsumer* target) {
   if (event.GetEventType() == ui::ET_TOUCH_RELEASED ||
       event.GetEventType() == ui::ET_TOUCH_CANCELLED) {
@@ skipping 35 matching lines @@
     return sequence->ProcessTouchEventForGesture(cancelled,
                                                  ui::TOUCH_STATUS_UNKNOWN);
   }
 
   return sequence->ProcessTouchEventForGesture(
       *event,
       processed ? ui::TOUCH_STATUS_CONTINUE : ui::TOUCH_STATUS_UNKNOWN);
 }
 
 void GestureRecognizerImpl::FlushTouchQueue(GestureConsumer* consumer) {
-  if (consumer_sequence_.count(consumer)) {
-    delete consumer_sequence_[consumer];
+  if (consumer_sequence_.count(consumer))
     consumer_sequence_.erase(consumer);
-  }
 
   if (event_queue_.count(consumer)) {
     delete event_queue_[consumer];
     event_queue_.erase(consumer);

[sadrul, 2012/08/02 18:29:55]

Perhaps we need to do the same for event_queue_ too? (we can probably also get
rid of the old TransferConsumer function.

[girard, 2012/08/02 19:33:54]

That makes sense.  I've updated the CL (second patch) to do this, and then added
a third patch that also changes TouchEventQueue.  I think this last patch cleans
up everything.

   }
 
   RemoveConsumerFromMap(consumer, &touch_id_target_);
   RemoveConsumerFromMap(consumer, &touch_id_target_for_gestures_);
 }
 
 // GestureRecognizer, static
 GestureRecognizer* GestureRecognizer::Create(GestureEventHelper* helper) {
   return new GestureRecognizerImpl(helper);
 }
 
 }  // namespace ui