x11: Use gfx::XScopedPtr<> in more places.

ui/views/widget/desktop_aura/desktop_window_tree_host_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/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 133 matching lines @@
       is_fullscreen_(false),
       is_always_on_top_(false),
       use_native_frame_(false),
       should_maximize_after_map_(false),
       use_argb_visual_(false),
       drag_drop_client_(NULL),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura),
       content_window_(NULL),
       window_parent_(NULL),
-      window_shape_(NULL),
       custom_window_shape_(false),
       urgency_hint_set_(false),
       close_widget_factory_(this) {
 }
 
 DesktopWindowTreeHostX11::~DesktopWindowTreeHostX11() {
   window()->ClearProperty(kHostForRootWindow);
   aura::client::SetWindowMoveClient(window(), NULL);
   desktop_native_widget_aura_->OnDesktopWindowTreeHostDestroyed(this);
-  if (window_shape_)
-    XDestroyRegion(window_shape_);
   DestroyDispatcher();
 }
 
 // static
 aura::Window* DesktopWindowTreeHostX11::GetContentWindowForXID(XID xid) {
   aura::WindowTreeHost* host =
       aura::WindowTreeHost::GetForAcceleratedWidget(xid);
   return host ? host->window()->GetProperty(kViewsWindowForRootWindow) : NULL;
 }
 
@@ skipping 18 matching lines @@
   return bounds_in_pixels_;
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetX11RootWindowOuterBounds() const {
   gfx::Rect outer_bounds(bounds_in_pixels_);
   outer_bounds.Inset(-native_window_frame_borders_in_pixels_);
   return outer_bounds;
 }
 
 ::Region DesktopWindowTreeHostX11::GetWindowShape() const {
-  return window_shape_;
+  return window_shape_.get();
 }
 
 void DesktopWindowTreeHostX11::HandleNativeWidgetActivationChanged(
     bool active) {
   if (active) {
     FlashFrame(false);
     OnHostActivated();
     open_windows().remove(xwindow_);
     open_windows().insert(open_windows().begin(), xwindow_);
   } else {
@@ skipping 264 matching lines @@
     return ToDIPRect(restored_bounds_in_pixels_);
 
   return GetWindowBoundsInScreen();
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetWorkAreaBoundsInScreen() const {
   return ToDIPRect(GetWorkAreaBoundsInPixels());
 }
 
 void DesktopWindowTreeHostX11::SetShape(gfx::NativeRegion native_region) {
-  if (window_shape_)
-    XDestroyRegion(window_shape_);
   custom_window_shape_ = false;
-  window_shape_ = NULL;
+  window_shape_.reset();
 
   if (native_region) {
     gfx::Transform transform = GetRootTransform();
     if (!transform.IsIdentity() && !native_region->isEmpty()) {
       SkPath path_in_dip;
       if (native_region->getBoundaryPath(&path_in_dip)) {
         SkPath path_in_pixels;
         path_in_dip.transform(transform.matrix(), &path_in_pixels);
-        window_shape_ = gfx::CreateRegionFromSkPath(path_in_pixels);
+        window_shape_.reset(gfx::CreateRegionFromSkPath(path_in_pixels));
       } else {
-        window_shape_ = XCreateRegion();
+        window_shape_.reset(XCreateRegion());
       }
     } else {
-      window_shape_ = gfx::CreateRegionFromSkRegion(*native_region);
+      window_shape_.reset(gfx::CreateRegionFromSkRegion(*native_region));
     }
 
     custom_window_shape_ = true;
     delete native_region;
   }
   ResetWindowRegion();
 }
 
 void DesktopWindowTreeHostX11::Activate() {
   if (!window_mapped_)
@@ skipping 954 matching lines @@
             display_dest.device_scale_factor());
   gfx::Vector2d offset = GetLocationOnNativeScreen() -
                          host->GetLocationOnNativeScreen();
   gfx::Point location_in_pixel_in_host = located_event->location() + offset;
   located_event->set_location(location_in_pixel_in_host);
 }
 
 void DesktopWindowTreeHostX11::ResetWindowRegion() {
   // If a custom window shape was supplied then apply it.
   if (custom_window_shape_) {
-    XShapeCombineRegion(
-        xdisplay_, xwindow_, ShapeBounding, 0, 0, window_shape_, false);
+    XShapeCombineRegion(xdisplay_, xwindow_, ShapeBounding, 0, 0,
+                        window_shape_.get(), false);
     return;
   }
 
-  if (window_shape_)
-    XDestroyRegion(window_shape_);
-  window_shape_ = NULL;
+  window_shape_.reset();
 
   if (!IsMaximized() && !IsFullscreen()) {
     gfx::Path window_mask;
     views::Widget* widget = native_widget_delegate_->AsWidget();
     if (widget->non_client_view()) {
       // Some frame views define a custom (non-rectangular) window mask. If
       // so, use it to define the window shape. If not, fall through.
       widget->non_client_view()->GetWindowMask(bounds_in_pixels_.size(),
                                                &window_mask);
       if (window_mask.countPoints() > 0) {
-        window_shape_ = gfx::CreateRegionFromSkPath(window_mask);
-        XShapeCombineRegion(xdisplay_, xwindow_, ShapeBounding,
-                            0, 0, window_shape_, false);
+        window_shape_.reset(gfx::CreateRegionFromSkPath(window_mask));
+        XShapeCombineRegion(xdisplay_, xwindow_, ShapeBounding, 0, 0,
+                            window_shape_.get(), false);
         return;
       }
     }
   }
 
   // If we didn't set the shape for any reason, reset the shaping information.
   // How this is done depends on the border style, due to quirks and bugs in
   // various window managers.
   if (ShouldUseNativeFrame()) {
     // If the window has system borders, the mask must be set to null (not a
@@ skipping 480 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views