Fix some memory leaks.

ui/base/touch/touch_factory.cc

 // Copyright (c) 2011 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/touch/touch_factory.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/XIproto.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/base/x/x11_util.h"
 
 namespace {
 
+// Keeps track of a string returned by an X function (e.g. XGetAtomName) and
+// makes sure it's XFree'd.
+class XScopedString {

[sky, 2012/02/06 21:43:00]

Should this live in ui/base/x?

[sadrul, 2012/02/07 19:45:24]

Sounds like a good idea. I moved this into x11_util (and used it in another
place XGetAtomName was being used)

+ public:
+  explicit XScopedString(const char *str) : string_(str) { }
+  ~XScopedString() {
+    XFree(string_);
+  }
+
+  const char *string() const { return string_; }
+
+ private:
+  const char *string_;
+
+  DISALLOW_COPY_AND_ASSIGN(XScopedString);
+};
+
 // The X cursor is hidden if it is idle for kCursorIdleSeconds seconds.
 int kCursorIdleSeconds = 5;
 
 // Given the TouchParam, return the correspoding XIValuatorClassInfo using
 // the X device information through Atom name matching.
 XIValuatorClassInfo* FindTPValuator(Display* display,
                                     XIDeviceInfo* info,
                                     ui::TouchFactory::TouchParam tp) {
   // Lookup table for mapping TouchParam to Atom string used in X.
   // A full set of Atom strings can be found at xserver-properties.h.
@@ skipping 27 matching lines @@
   if (!atom_tp)
     return NULL;
 
   for (int i = 0; i < info->num_classes; i++) {
     if (info->classes[i]->type != XIValuatorClass)
       continue;
     XIValuatorClassInfo* v =
         reinterpret_cast<XIValuatorClassInfo*>(info->classes[i]);
 
     if (v->label) {
-      const char* atom = XGetAtomName(display, v->label);
-      if (atom && strcmp(atom, atom_tp) == 0)
+      XScopedString atom(XGetAtomName(display, v->label));
+      if (atom.string() && strcmp(atom.string(), atom_tp) == 0)
         return v;
     }
   }
 
   return NULL;
 }
 
 }  // namespace
 
 namespace ui {
@@ skipping 65 matching lines @@
   // If XInput2 is not supported, this will return null (with count of -1) so
   // we assume there cannot be any touch devices.
   int count = 0;
   touch_device_available_ = false;
   touch_device_lookup_.reset();
   touch_device_list_.clear();
 #if !defined(USE_XI2_MT)
   XDeviceInfo* devlist = XListInputDevices(display, &count);
   for (int i = 0; i < count; i++) {
     if (devlist[i].type) {
-      const char* devtype = XGetAtomName(display, devlist[i].type);
-      if (devtype && !strcmp(devtype, XI_TOUCHSCREEN)) {
+      XScopedString devtype(XGetAtomName(display, devlist[i].type));
+      if (devtype.string() && !strcmp(devtype.string(), XI_TOUCHSCREEN)) {
         touch_device_lookup_[devlist[i].id] = true;
         touch_device_list_[devlist[i].id] = true;
         touch_device_available_ = true;
       }
     }
   }
   if (devlist)
     XFreeDeviceList(devlist);
 #endif
 
@@ skipping 327 matching lines @@
                                       float* max) {
   if (valuator_lookup_[deviceid][tp] >= 0) {
     *min = touch_param_min_[deviceid][tp];
     *max = touch_param_max_[deviceid][tp];
     return true;
   }
   return false;
 }
 
 }  // namespace ui