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

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 687 matching lines @@
   // of the client input region with both the default input region and the
   // client bounding region. Any portion of the client input region that is not
   // included in both the default input region and the client bounding region
   // will not be included in the effective input region on the screen.
   int rectangle_kind[] = {ShapeInput, ShapeBounding};
   for (size_t kind_index = 0;
        kind_index < arraysize(rectangle_kind);
        kind_index++) {
     int dummy;
     int shape_rects_size = 0;
-    XRectangle* shape_rects = XShapeGetRectangles(gfx::GetXDisplay(),
-                                                  window,
-                                                  rectangle_kind[kind_index],
-                                                  &shape_rects_size,
-                                                  &dummy);
+    gfx::XScopedPtr<XRectangle[]> shape_rects(XShapeGetRectangles(
+        gfx::GetXDisplay(), window, rectangle_kind[kind_index],
+        &shape_rects_size, &dummy));
     if (!shape_rects) {
       // The shape is empty. This can occur when |window| is minimized.
       DCHECK_EQ(0, shape_rects_size);
       return false;
     }
     bool is_in_shape_rects = false;
     for (int i = 0; i < shape_rects_size; ++i) {
       // The ShapeInput and ShapeBounding rects are to be in window space, so we
       // have to translate by the window_rect's offset to map to screen space.
+      const XRectangle& rect = shape_rects[i];
       gfx::Rect shape_rect =
-          gfx::Rect(shape_rects[i].x + window_rect.x(),
-                    shape_rects[i].y + window_rect.y(),
-                    shape_rects[i].width, shape_rects[i].height);
+          gfx::Rect(rect.x + window_rect.x(), rect.y + window_rect.y(),
+                    rect.width, rect.height);
       if (shape_rect.Contains(screen_loc)) {
         is_in_shape_rects = true;
         break;
       }
     }
-    XFree(shape_rects);
     if (!is_in_shape_rects)
       return false;
   }
   return true;
 }
 
 
 bool PropertyExists(XID window, const std::string& property_name) {
   XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
+  gfx::XScopedPtr<unsigned char> scoped_property(property);
   if (result != Success)
     return false;
 
-  XFree(property);
   return num_items > 0;
 }
 
 bool GetRawBytesOfProperty(XID window,
                            XAtom property,
                            scoped_refptr<base::RefCountedMemory>* out_data,
                            size_t* out_data_items,
                            XAtom* out_type) {
   // Retrieve the data from our window.
   unsigned long nitems = 0;
   unsigned long nbytes = 0;
   XAtom prop_type = None;
   int prop_format = 0;
   unsigned char* property_data = NULL;
   if (XGetWindowProperty(gfx::GetXDisplay(), window, property,
                          0, 0x1FFFFFFF /* MAXINT32 / 4 */, False,
                          AnyPropertyType, &prop_type, &prop_format,
                          &nitems, &nbytes, &property_data) != Success) {
     return false;
   }
+  gfx::XScopedPtr<unsigned char> scoped_property(property_data);
 
   if (prop_type == None)
     return false;
 
   size_t bytes = 0;
   // So even though we should theoretically have nbytes (and we can't
   // pass NULL there), we need to manually calculate the byte length here
   // because nbytes always returns zero.
   switch (prop_format) {
     case 8:
       bytes = nitems;
       break;
     case 16:
       bytes = sizeof(short) * nitems;
       break;
     case 32:
       bytes = sizeof(long) * nitems;
       break;
     default:
       NOTREACHED();
       break;
   }
 
   if (out_data)
-    *out_data = new XRefcountedMemory(property_data, bytes);
-  else
-    XFree(property_data);
+    *out_data = new XRefcountedMemory(scoped_property.release(), bytes);
 
   if (out_data_items)
     *out_data_items = nitems;
 
   if (out_type)
     *out_type = prop_type;
 
   return true;
 }
 
 bool GetIntProperty(XID window, const std::string& property_name, int* value) {
   XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
+  gfx::XScopedPtr<unsigned char> scoped_property(property);
   if (result != Success)
     return false;
 
-  if (format != 32 || num_items != 1) {
-    XFree(property);
+  if (format != 32 || num_items != 1)
     return false;
-  }
 
   *value = static_cast<int>(*(reinterpret_cast<long*>(property)));
-  XFree(property);
   return true;
 }
 
 bool GetXIDProperty(XID window, const std::string& property_name, XID* value) {
   XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
+  gfx::XScopedPtr<unsigned char> scoped_property(property);
   if (result != Success)
     return false;
 
-  if (format != 32 || num_items != 1) {
-    XFree(property);
+  if (format != 32 || num_items != 1)
     return false;
-  }
 
   *value = *(reinterpret_cast<XID*>(property));
-  XFree(property);
   return true;
 }
 
 bool GetIntArrayProperty(XID window,
                          const std::string& property_name,
                          std::vector<int>* value) {
   XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
 
   int result = GetProperty(window, property_name,
                            (~0L), // (all of them)
                            &type, &format, &num_items, &properties);
+  gfx::XScopedPtr<unsigned char> scoped_properties(properties);
   if (result != Success)
     return false;
 
-  if (format != 32) {
-    XFree(properties);
+  if (format != 32)
     return false;
-  }
 
   long* int_properties = reinterpret_cast<long*>(properties);
   value->clear();
   for (unsigned long i = 0; i < num_items; ++i) {
     value->push_back(static_cast<int>(int_properties[i]));
   }
-  XFree(properties);
   return true;
 }
 
 bool GetAtomArrayProperty(XID window,
                           const std::string& property_name,
                           std::vector<XAtom>* value) {
   XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
 
   int result = GetProperty(window, property_name,
                            (~0L), // (all of them)
                            &type, &format, &num_items, &properties);
+  gfx::XScopedPtr<unsigned char> scoped_properties(properties);
   if (result != Success)
     return false;
 
-  if (type != XA_ATOM) {
-    XFree(properties);
+  if (type != XA_ATOM)
     return false;
-  }
 
   XAtom* atom_properties = reinterpret_cast<XAtom*>(properties);
   value->clear();
   value->insert(value->begin(), atom_properties, atom_properties + num_items);
-  XFree(properties);
   return true;
 }
 
 bool GetStringProperty(
     XID window, const std::string& property_name, std::string* value) {
   XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1024,
                            &type, &format, &num_items, &property);
+  gfx::XScopedPtr<unsigned char> scoped_property(property);
   if (result != Success)
     return false;
 
-  if (format != 8) {
-    XFree(property);
+  if (format != 8)
     return false;
-  }
 
   value->assign(reinterpret_cast<char*>(property), num_items);
-  XFree(property);
   return true;
 }
 
 bool SetIntProperty(XID window,
                     const std::string& name,
                     const std::string& type,
                     int value) {
   std::vector<int> values(1, value);
   return SetIntArrayProperty(window, name, type, values);
 }
@@ skipping 238 matching lines @@
   unsigned char *data = NULL;
   if (GetProperty(window,
                   "_NET_CLIENT_LIST_STACKING",
                   ~0L,
                   &type,
                   &format,
                   &count,
                   &data) != Success) {
     return false;
   }
+  gfx::XScopedPtr<unsigned char> scoped_data(data);
 
   bool result = false;
   if (type == XA_WINDOW && format == 32 && data && count > 0) {
     result = true;
     XID* stack = reinterpret_cast<XID*>(data);
     for (long i = static_cast<long>(count) - 1; i >= 0; i--)
       windows->push_back(stack[i]);
   }
 
-  if (data)
-    XFree(data);
-
   return result;
 }
 
 bool CopyAreaToCanvas(XID drawable,
                       gfx::Rect source_bounds,
                       gfx::Point dest_offset,
                       gfx::Canvas* canvas) {
   ui::XScopedImage scoped_image(
       XGetImage(gfx::GetXDisplay(), drawable,
                 source_bounds.x(), source_bounds.y(),
@@ skipping 140 matching lines @@
   if (!GetAtomArrayProperty(GetX11RootWindow(),
                             "_NET_SUPPORTED",
                             &supported_atoms)) {
     return false;
   }
 
   return std::find(supported_atoms.begin(), supported_atoms.end(), atom) !=
       supported_atoms.end();
 }
 
+XRefcountedMemory::XRefcountedMemory(unsigned char* x11_data, size_t length)
+    : x11_data_(length ? x11_data : nullptr), length_(length) {
+}
+
 const unsigned char* XRefcountedMemory::front() const {
-  return x11_data_;
+  return x11_data_.get();
 }
 
 size_t XRefcountedMemory::size() const {
   return length_;
 }
 
 XRefcountedMemory::~XRefcountedMemory() {
-  XFree(x11_data_);
-}
-
-XScopedString::~XScopedString() {
-  XFree(string_);
 }
 
 XScopedImage::~XScopedImage() {
   reset(NULL);
 }
 
 void XScopedImage::reset(XImage* image) {
   if (image_ == image)
     return;
   if (image_)
@@ skipping 86 matching lines @@
   XGetErrorText(dpy, error_event.error_code, error_str, sizeof(error_str));
 
   strncpy(request_str, "Unknown", sizeof(request_str));
   if (error_event.request_code < 128) {
     std::string num = base::UintToString(error_event.request_code);
     XGetErrorDatabaseText(
         dpy, "XRequest", num.c_str(), "Unknown", request_str,
         sizeof(request_str));
   } else {
     int num_ext;
-    char** ext_list = XListExtensions(dpy, &num_ext);
+    gfx::XScopedPtr<char* [],
+                    gfx::XObjectDeleter<char*, int, XFreeExtensionList>>
+        ext_list(XListExtensions(dpy, &num_ext));
 
     for (int i = 0; i < num_ext; i++) {
       int ext_code, first_event, first_error;
       XQueryExtension(dpy, ext_list[i], &ext_code, &first_event, &first_error);
       if (error_event.request_code == ext_code) {
         std::string msg = base::StringPrintf(
             "%s.%d", ext_list[i], error_event.minor_code);
         XGetErrorDatabaseText(
             dpy, "XRequest", msg.c_str(), "Unknown", request_str,
             sizeof(request_str));
         break;
       }
     }
-    XFreeExtensionList(ext_list);
   }
 
   LOG(WARNING)
       << "X error received: "
       << "serial " << error_event.serial << ", "
       << "error_code " << static_cast<int>(error_event.error_code)
       << " (" << error_str << "), "
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui