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

ui/display/chromeos/x11/native_display_delegate_x11.cc

 // Copyright 2014 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/display/chromeos/x11/native_display_delegate_x11.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 382 matching lines @@
   unsigned char* values = NULL;
   int actual_format = 0;
   unsigned long nitems = 0;
   unsigned long bytes_after = 0;
   Atom actual_type = None;
   int success = 0;
   RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
   // TODO(kcwu): Use X11AtomCache to save round trip time of XInternAtom.
   Atom prop = XInternAtom(display_, kContentProtectionAtomName, False);
 
-  bool ok = true;
   // TODO(kcwu): Move this to x11_util (similar method calls in this file and
   // output_util.cc)
   success = XRRGetOutputProperty(display_,
                                  output_id,
                                  prop,
                                  0,
                                  100,
                                  False,
                                  False,
                                  AnyPropertyType,
                                  &actual_type,
                                  &actual_format,
                                  &nitems,
                                  &bytes_after,
                                  &values);
+  gfx::XScopedPtr<unsigned char> scoped_values(values);
   if (actual_type == None) {
     LOG(ERROR) << "Property '" << kContentProtectionAtomName
                << "' does not exist";
-    ok = false;
-  } else if (success == Success && actual_type == XA_ATOM &&
-             actual_format == 32 && nitems == 1) {
+    return false;
+  }
+
+  if (success == Success && actual_type == XA_ATOM && actual_format == 32 &&
+      nitems == 1) {
     Atom value = reinterpret_cast<Atom*>(values)[0];
     if (value == XInternAtom(display_, kProtectionUndesiredAtomName, False)) {
       *state = HDCP_STATE_UNDESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionDesiredAtomName, False)) {
       *state = HDCP_STATE_DESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionEnabledAtomName, False)) {
       *state = HDCP_STATE_ENABLED;
     } else {
       LOG(ERROR) << "Unknown " << kContentProtectionAtomName
                  << " value: " << value;
-      ok = false;
+      return false;
     }
   } else {
     LOG(ERROR) << "XRRGetOutputProperty failed";
-    ok = false;
+    return false;
   }
-  if (values)
-    XFree(values);
 
-  VLOG(3) << "HDCP state: " << ok << "," << *state;
-  return ok;
+  VLOG(3) << "HDCP state: success," << *state;
+  return true;
 }
 
 bool NativeDisplayDelegateX11::SetHDCPState(const DisplaySnapshot& output,
                                             HDCPState state) {
   Atom name = XInternAtom(display_, kContentProtectionAtomName, False);
   Atom value = None;
   switch (state) {
     case HDCP_STATE_UNDESIRED:
       value = XInternAtom(display_, kProtectionUndesiredAtomName, False);
       break;
@@ skipping 72 matching lines @@
         output = None;
         mode_info = NULL;
       }
     }
 
     ConfigureCrtc(x11_output->crtc(), mode, output, 0, 0);
   }
 }
 
 bool NativeDisplayDelegateX11::IsOutputAspectPreservingScaling(RROutput id) {
-  bool ret = false;
-
   Atom scaling_prop = XInternAtom(display_, "scaling mode", False);
   Atom full_aspect_atom = XInternAtom(display_, "Full aspect", False);
   if (scaling_prop == None || full_aspect_atom == None)
     return false;
 
   int nprop = 0;
-  Atom* props = XRRListOutputProperties(display_, id, &nprop);
-  for (int j = 0; j < nprop && !ret; j++) {
+  gfx::XScopedPtr<Atom[]> props(XRRListOutputProperties(display_, id, &nprop));
+  for (int j = 0; j < nprop; j++) {
     Atom prop = props[j];
     if (scaling_prop == prop) {
       unsigned char* values = NULL;
       int actual_format;
       unsigned long nitems;
       unsigned long bytes_after;
       Atom actual_type;
       int success;
 
       success = XRRGetOutputProperty(display_,
                                      id,
                                      prop,
                                      0,
                                      100,
                                      False,
                                      False,
                                      AnyPropertyType,
                                      &actual_type,
                                      &actual_format,
                                      &nitems,
                                      &bytes_after,
                                      &values);
+      gfx::XScopedPtr<unsigned char> scoped_value(values);
       if (success == Success && actual_type == XA_ATOM && actual_format == 32 &&
           nitems == 1) {
         Atom value = reinterpret_cast<Atom*>(values)[0];
         if (full_aspect_atom == value)
-          ret = true;
+          return true;
       }
-      if (values)
-        XFree(values);
     }
   }
-  if (props)
-    XFree(props);
-
-  return ret;
+  return false;
 }
 
 
 std::vector<ColorCalibrationProfile>
 NativeDisplayDelegateX11::GetAvailableColorCalibrationProfiles(
     const DisplaySnapshot& output) {
   // TODO(mukai|marcheu): Checks the system data and fills the result.
   // Note that the order would be Dynamic -> Standard -> Movie -> Reading.
   return std::vector<ColorCalibrationProfile>();
 }
@@ skipping 44 matching lines @@
   XSetForeground(display_, gc, color.pixel);
   XSetFillStyle(display_, gc, FillSolid);
   int width = DisplayWidth(display_, DefaultScreen(display_));
   int height = DisplayHeight(display_, DefaultScreen(display_));
   XFillRectangle(display_, window_, gc, 0, 0, width, height);
   XFreeGC(display_, gc);
   XFreeColors(display_, colormap, &color.pixel, 1, 0);
 }
 
 }  // namespace ui