x11/test: Use a custom-deleter for the stored XEvent.

ui/events/test/events_test_utils_x11.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 "ui/events/test/events_test_utils_x11.h"
 
 #include <X11/extensions/XI2.h>
 #include <X11/keysym.h>
 #include <X11/X.h>
 #include <X11/Xlib.h>
@@ skipping 117 matching lines @@
     xiev->buttons.mask = new unsigned char[xiev->buttons.mask_len];
     memset(xiev->buttons.mask, 0, xiev->buttons.mask_len);
   }
   return event;
 }
 
 }  // namespace
 
 namespace ui {
 
+void XEventDeleter::operator()(XEvent* event) {

[sky, 2014/02/03 04:48:31]

Can you add some comments as to why this is necessary. Or maybe if it's already
documented why else where in the point add a reference to that.

[sadrul, 2014/02/03 15:58:18]

Done (added a comment explaining why this is necessary).

+  if (event->type != GenericEvent)
+    return;
+  XIDeviceEvent* xiev =
+      static_cast<XIDeviceEvent*>(event->xcookie.data);
+  if (xiev) {
+    delete[] xiev->valuators.mask;
+    delete[] xiev->valuators.values;
+    delete[] xiev->buttons.mask;
+    delete xiev;
+  }
+}
+
 ScopedXI2Event::ScopedXI2Event() {}
-ScopedXI2Event::~ScopedXI2Event() {
-  Cleanup();
-}
+ScopedXI2Event::~ScopedXI2Event() {}
 
 void ScopedXI2Event::InitKeyEvent(EventType type,
                                   KeyboardCode key_code,
                                   int flags) {
-  Cleanup();
   XDisplay* display = gfx::GetXDisplay();
   event_.reset(new XEvent);
   memset(event_.get(), 0, sizeof(XEvent));
   event_->type = XKeyEventType(type);
   CHECK_NE(0, event_->type);
   event_->xkey.serial = 0;
   event_->xkey.send_event = 0;
   event_->xkey.display = display;
   event_->xkey.time = 0;
   event_->xkey.window = 0;
   event_->xkey.root = 0;
   event_->xkey.subwindow = 0;
   event_->xkey.x = 0;
   event_->xkey.y = 0;
   event_->xkey.x_root = 0;
   event_->xkey.y_root = 0;
   event_->xkey.state = XEventState(flags);
   event_->xkey.keycode = XKeyEventKeyCode(key_code, flags, display);
   event_->xkey.same_screen = 1;
 }
 
 void ScopedXI2Event::InitGenericButtonEvent(int deviceid,
                                             EventType type,
                                             int flags) {
-  Cleanup();
   event_.reset(CreateXInput2Event(deviceid,
                                   XIButtonEventType(type), 0, gfx::Point()));
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event_->xcookie.data);
   xievent->mods.effective = XEventState(flags);
   xievent->detail = XButtonEventButton(type, flags);
   XISetMask(xievent->buttons.mask, xievent->detail);
 }
 
 void ScopedXI2Event::InitButtonEvent(EventType type,
                                      int flags) {
-  Cleanup();
   event_.reset(new XEvent);
   memset(event_.get(), 0, sizeof(XEvent));
   event_->type = XButtonEventType(type);
   CHECK_NE(0, event_->type);
   event_->xbutton.serial = 0;
   event_->xbutton.send_event = 0;
   event_->xbutton.display = gfx::GetXDisplay();
   event_->xbutton.time = 0;
   event_->xbutton.window = 0;
   event_->xbutton.root = 0;
@@ skipping 14 matching lines @@
   // at the moment.
   event_->xbutton.button = wheel_delta > 0 ? Button4 : Button5;
 }
 
 void ScopedXI2Event::InitScrollEvent(int deviceid,
                                      int x_offset,
                                      int y_offset,
                                      int x_offset_ordinal,
                                      int y_offset_ordinal,
                                      int finger_count) {
-  Cleanup();
   event_.reset(CreateXInput2Event(deviceid, XI_Motion, 0, gfx::Point()));
 
   Valuator valuators[] = {
     Valuator(DeviceDataManager::DT_CMT_SCROLL_X, x_offset),
     Valuator(DeviceDataManager::DT_CMT_SCROLL_Y, y_offset),
     Valuator(DeviceDataManager::DT_CMT_ORDINAL_X, x_offset_ordinal),
     Valuator(DeviceDataManager::DT_CMT_ORDINAL_Y, y_offset_ordinal),
     Valuator(DeviceDataManager::DT_CMT_FINGER_COUNT, finger_count)
   };
   SetUpValuators(
       std::vector<Valuator>(valuators, valuators + arraysize(valuators)));
 }
 
 void ScopedXI2Event::InitFlingScrollEvent(int deviceid,
                                           int x_velocity,
                                           int y_velocity,
                                           int x_velocity_ordinal,
                                           int y_velocity_ordinal,
                                           bool is_cancel) {
-  Cleanup();
   event_.reset(CreateXInput2Event(deviceid, XI_Motion, deviceid, gfx::Point()));
 
   Valuator valuators[] = {
     Valuator(DeviceDataManager::DT_CMT_FLING_STATE, is_cancel ? 1 : 0),
     Valuator(DeviceDataManager::DT_CMT_FLING_Y, y_velocity),
     Valuator(DeviceDataManager::DT_CMT_ORDINAL_Y, y_velocity_ordinal),
     Valuator(DeviceDataManager::DT_CMT_FLING_X, x_velocity),
     Valuator(DeviceDataManager::DT_CMT_ORDINAL_X, x_velocity_ordinal)
   };
 
   SetUpValuators(
       std::vector<Valuator>(valuators, valuators + arraysize(valuators)));
 }
 
 void ScopedXI2Event::InitTouchEvent(int deviceid,
                                     int evtype,
                                     int tracking_id,
                                     const gfx::Point& location,
                                     const std::vector<Valuator>& valuators) {
-  Cleanup();
   event_.reset(CreateXInput2Event(deviceid, evtype, tracking_id, location));
   SetUpValuators(valuators);
 }
 
-void ScopedXI2Event::Cleanup() {
-  if (event_.get() && event_->type == GenericEvent) {
-    XIDeviceEvent* xiev =
-        static_cast<XIDeviceEvent*>(event_->xcookie.data);
-    if (xiev) {
-      delete[] xiev->valuators.mask;
-      delete[] xiev->valuators.values;
-      delete[] xiev->buttons.mask;
-      delete xiev;
-    }
-  }
-  event_.reset();
-}
-
 void ScopedXI2Event::SetUpValuators(const std::vector<Valuator>& valuators) {
   CHECK(event_.get());
   CHECK_EQ(GenericEvent, event_->type);
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(event_->xcookie.data);
   InitValuatorsForXIDeviceEvent(xiev);
   ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
   for (size_t i = 0; i < valuators.size(); ++i) {
     manager->SetValuatorDataForTest(xiev, valuators[i].data_type,
                                     valuators[i].value);
   }
 }
 
 void SetUpScrollDeviceForTest(unsigned int deviceid) {
   std::vector<unsigned int> device_list;
   device_list.push_back(deviceid);
 
   TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
   ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
   manager->SetDeviceListForTest(std::vector<unsigned int>(), device_list);
 }
 
 void SetUpTouchDevicesForTest(const std::vector<unsigned int>& devices) {
   TouchFactory::GetInstance()->SetTouchDeviceForTest(devices);
   ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
   manager->SetDeviceListForTest(devices, std::vector<unsigned int>());
 }
 
 }  // namespace ui