x11: Use scoped_ptr<> for X11 objects where it makes sense.

ui/events/devices/x11/touch_factory_x11.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/devices/x11/touch_factory_x11.h"
 
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 71 matching lines @@
   touch_device_lookup_.reset();
   touch_device_list_.clear();
   touchscreen_ids_.clear();
 
   // NOTE: The new API for retrieving the list of devices (XIQueryDevice) does
   // not provide enough information to detect a touch device. As a result, the
   // old version of query function (XListInputDevices) is used instead.
   // If XInput2 is not supported, this will return null (with count of -1) so
   // we assume there cannot be any touch devices.
   // With XI2.1 or older, we allow only single touch devices.
-  XDeviceList dev_list =
+  const XDeviceList& dev_list =
       DeviceListCacheX11::GetInstance()->GetXDeviceList(display);
   Atom xi_touchscreen = XInternAtom(display, XI_TOUCHSCREEN, false);
   for (int i = 0; i < dev_list.count; i++) {
     if (dev_list[i].type == xi_touchscreen) {
       touch_device_lookup_[dev_list[i].id] = true;
       touch_device_list_[dev_list[i].id] = false;
     }
   }
 
   if (!DeviceDataManagerX11::GetInstance()->IsXInput2Available())
     return;
 
   // Instead of asking X for the list of devices all the time, let's maintain a
   // list of pointer devices we care about.
   // It should not be necessary to select for slave devices. XInput2 provides
   // enough information to the event callback to decide which slave device
   // triggered the event, thus decide whether the 'pointer event' is a
   // 'mouse event' or a 'touch event'.
   // However, on some desktops, some events from a master pointer are
   // not delivered to the client. So we select for slave devices instead.
   // If the touch device has 'GrabDevice' set and 'SendCoreEvents' unset (which
   // is possible), then the device is detected as a floating device, and a
   // floating device is not connected to a master device. So it is necessary to
   // also select on the floating devices.
   pointer_device_lookup_.reset();
-  XIDeviceList xi_dev_list =
+  const XIDeviceList& xi_dev_list =
       DeviceListCacheX11::GetInstance()->GetXI2DeviceList(display);
   for (int i = 0; i < xi_dev_list.count; i++) {
-    XIDeviceInfo* devinfo = xi_dev_list.devices + i;
-    if (devinfo->use == XIFloatingSlave || devinfo->use == XIMasterPointer) {
-      for (int k = 0; k < devinfo->num_classes; ++k) {
-        XIAnyClassInfo* xiclassinfo = devinfo->classes[k];
+    const XIDeviceInfo& devinfo = xi_dev_list[i];
+    if (devinfo.use == XIFloatingSlave || devinfo.use == XIMasterPointer) {
+      for (int k = 0; k < devinfo.num_classes; ++k) {
+        XIAnyClassInfo* xiclassinfo = devinfo.classes[k];
         if (xiclassinfo->type == XITouchClass) {
           XITouchClassInfo* tci =
               reinterpret_cast<XITouchClassInfo*>(xiclassinfo);
           // Only care direct touch device (such as touch screen) right now
           if (tci->mode == XIDirectTouch) {
-            touch_device_lookup_[devinfo->deviceid] = true;
-            touch_device_list_[devinfo->deviceid] = true;
+            touch_device_lookup_[devinfo.deviceid] = true;
+            touch_device_list_[devinfo.deviceid] = true;
           }
         }
       }
-      pointer_device_lookup_[devinfo->deviceid] = true;
-    } else if (devinfo->use == XIMasterKeyboard) {
-      virtual_core_keyboard_device_ = devinfo->deviceid;
+      pointer_device_lookup_[devinfo.deviceid] = true;
+    } else if (devinfo.use == XIMasterKeyboard) {
+      virtual_core_keyboard_device_ = devinfo.deviceid;
     }
 
-    if (devinfo->use == XIFloatingSlave || devinfo->use == XISlavePointer) {
-      for (int k = 0; k < devinfo->num_classes; ++k) {
-        XIAnyClassInfo* xiclassinfo = devinfo->classes[k];
+    if (devinfo.use == XIFloatingSlave || devinfo.use == XISlavePointer) {
+      for (int k = 0; k < devinfo.num_classes; ++k) {
+        XIAnyClassInfo* xiclassinfo = devinfo.classes[k];
         if (xiclassinfo->type == XITouchClass) {
           XITouchClassInfo* tci =
               reinterpret_cast<XITouchClassInfo*>(xiclassinfo);
           // Only care direct touch device (such as touch screen) right now
           if (tci->mode == XIDirectTouch)
-            CacheTouchscreenIds(display, devinfo->deviceid);
+            CacheTouchscreenIds(display, devinfo.deviceid);
         }
       }
     }
   }
 }
 
 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
   DCHECK_EQ(GenericEvent, xev->type);
   XIEvent* event = static_cast<XIEvent*>(xev->xcookie.data);
   XIDeviceEvent* xiev = reinterpret_cast<XIDeviceEvent*>(event);
@@ skipping 165 matching lines @@
       if (ptr[0] || ptr[1])
         touchscreen_ids_.insert(std::make_pair(ptr[0], ptr[1]));
     }
     XFree(prop_return);
   }
 
   XCloseDevice(display, device);
 }
 
 }  // namespace ui