Make various views SetShape() methods take an unique_ptr.

ui/views/widget/desktop_aura/x11_topmost_window_finder_interactive_uitest.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/views/widget/desktop_aura/x11_topmost_window_finder.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xregion.h>
 #include <X11/extensions/shape.h>
 #include <stddef.h>
@@ skipping 27 matching lines @@
 
 namespace views {
 
 namespace {
 
 // Waits till |window| is minimized.
 class MinimizeWaiter : public X11PropertyChangeWaiter {
  public:
   explicit MinimizeWaiter(XID window)
       : X11PropertyChangeWaiter(window, "_NET_WM_STATE") {
-    const char* kAtomsToCache[] = { "_NET_WM_STATE_HIDDEN", NULL };
+    const char* const kAtomsToCache[] = {"_NET_WM_STATE_HIDDEN", nullptr};
     atom_cache_.reset(new ui::X11AtomCache(gfx::GetXDisplay(), kAtomsToCache));
   }
 
   ~MinimizeWaiter() override {}
 
  private:
   // X11PropertyChangeWaiter:
   bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<Atom> wm_states;
     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &wm_states)) {
@@ skipping 18 matching lines @@
                                 "_NET_CLIENT_LIST_STACKING"),
         expected_windows_(expected_windows, expected_windows + count) {
   }
 
   ~StackingClientListWaiter() override {}
 
   // X11PropertyChangeWaiter:
   void Wait() override {
     // StackingClientListWaiter may be created after
     // _NET_CLIENT_LIST_STACKING already contains |expected_windows|.
-    if (!ShouldKeepOnWaiting(NULL))
+    if (!ShouldKeepOnWaiting(nullptr))
       return;
 
     X11PropertyChangeWaiter::Wait();
   }
 
  private:
   // X11PropertyChangeWaiter:
   bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<XID> stack;
     ui::GetXWindowStack(ui::GetX11RootWindow(), &stack);
@@ skipping 143 matching lines @@
 
   XID xids[] = { xid1, xid2, xid3 };
   StackingClientListWaiter waiter(xids, arraysize(xids));
   waiter.Wait();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   EXPECT_EQ(xid1, FindTopmostXWindowAt(150, 150));
   EXPECT_EQ(window1, FindTopmostLocalProcessWindowAt(150, 150));
 
   EXPECT_EQ(xid2, FindTopmostXWindowAt(250, 150));
-  EXPECT_EQ(NULL, FindTopmostLocalProcessWindowAt(250, 150));
+  EXPECT_FALSE(FindTopmostLocalProcessWindowAt(250, 150));
 
   EXPECT_EQ(xid3, FindTopmostXWindowAt(250, 250));
   EXPECT_EQ(window3, FindTopmostLocalProcessWindowAt(250, 250));
 
   EXPECT_EQ(xid3, FindTopmostXWindowAt(150, 250));
   EXPECT_EQ(window3, FindTopmostLocalProcessWindowAt(150, 250));
 
   EXPECT_EQ(xid3, FindTopmostXWindowAt(150, 195));
   EXPECT_EQ(window3, FindTopmostLocalProcessWindowAt(150, 195));
 
   EXPECT_NE(xid1, FindTopmostXWindowAt(1000, 1000));
   EXPECT_NE(xid2, FindTopmostXWindowAt(1000, 1000));
   EXPECT_NE(xid3, FindTopmostXWindowAt(1000, 1000));
-  EXPECT_EQ(NULL, FindTopmostLocalProcessWindowAt(1000, 1000));
+  EXPECT_FALSE(FindTopmostLocalProcessWindowAt(1000, 1000));
 
   EXPECT_EQ(window1,
             FindTopmostLocalProcessWindowWithIgnore(150, 150, window3));
-  EXPECT_EQ(NULL,
-            FindTopmostLocalProcessWindowWithIgnore(250, 250, window3));
-  EXPECT_EQ(NULL,
-            FindTopmostLocalProcessWindowWithIgnore(150, 250, window3));
+  EXPECT_FALSE(FindTopmostLocalProcessWindowWithIgnore(250, 250, window3));
+  EXPECT_FALSE(FindTopmostLocalProcessWindowWithIgnore(150, 250, window3));
   EXPECT_EQ(window1,
             FindTopmostLocalProcessWindowWithIgnore(150, 195, window3));
 
   XDestroyWindow(xdisplay(), xid2);
 }
 
 // Test that the minimized state is properly handled.
 TEST_F(X11TopmostWindowFinderTest, Minimized) {
   std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
@@ skipping 30 matching lines @@
 }
 
 // Test that non-rectangular windows are properly handled.
 TEST_F(X11TopmostWindowFinderTest, NonRectangular) {
   if (!ui::IsShapeExtensionAvailable())
     return;
 
   std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
-  SkRegion* skregion1 = new SkRegion;
+  auto skregion1 = base::MakeUnique<SkRegion>();
   skregion1->op(SkIRect::MakeXYWH(0, 10, 10, 90), SkRegion::kUnion_Op);
   skregion1->op(SkIRect::MakeXYWH(10, 0, 90, 100), SkRegion::kUnion_Op);
-  // Widget takes ownership of |skregion1|.
-  widget1->SetShape(skregion1);
+  widget1->SetShape(std::move(skregion1));
 
   SkRegion skregion2;
   skregion2.op(SkIRect::MakeXYWH(0, 10, 10, 90), SkRegion::kUnion_Op);
   skregion2.op(SkIRect::MakeXYWH(10, 0, 90, 100), SkRegion::kUnion_Op);
   XID xid2 = CreateAndShowXWindow(gfx::Rect(300, 100, 100, 100));
   gfx::XScopedPtr<REGION, gfx::XObjectDeleter<REGION, int, XDestroyRegion>>
       region2(gfx::CreateRegionFromSkRegion(skregion2));
   XShapeCombineRegion(xdisplay(), xid2, ShapeBounding, 0, 0, region2.get(),
                       false);
   XID xids[] = { xid1, xid2 };
@@ skipping 15 matching lines @@
 }
 
 // Test that a window with an empty shape are properly handled.
 TEST_F(X11TopmostWindowFinderTest, NonRectangularEmptyShape) {
   if (!ui::IsShapeExtensionAvailable())
     return;
 
   std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
-  SkRegion* skregion1 = new SkRegion;
+  auto skregion1 = base::MakeUnique<SkRegion>();
   skregion1->op(SkIRect::MakeXYWH(0, 0, 0, 0), SkRegion::kUnion_Op);
   // Widget takes ownership of |skregion1|.
-  widget1->SetShape(skregion1);
+  widget1->SetShape(std::move(skregion1));
 
   XID xids[] = { xid1 };
   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
   stack_waiter.Wait();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   EXPECT_NE(xid1, FindTopmostXWindowAt(105, 105));
 }
 
 // Test that setting a Null shape removes the shape.
 TEST_F(X11TopmostWindowFinderTest, NonRectangularNullShape) {
   if (!ui::IsShapeExtensionAvailable())
     return;
 
   std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
-  SkRegion* skregion1 = new SkRegion;
+  auto skregion1 = base::MakeUnique<SkRegion>();
   skregion1->op(SkIRect::MakeXYWH(0, 0, 0, 0), SkRegion::kUnion_Op);
-  // Widget takes ownership of |skregion1|.
-  widget1->SetShape(skregion1);
+  widget1->SetShape(std::move(skregion1));
 
   // Remove the shape - this is now just a normal window.
-  widget1->SetShape(NULL);
+  widget1->SetShape(nullptr);
 
   XID xids[] = { xid1 };
   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
   stack_waiter.Wait();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   EXPECT_EQ(xid1, FindTopmostXWindowAt(105, 105));
 }
 
 // Test that the TopmostWindowFinder finds windows which belong to menus
 // (which may or may not belong to Chrome).
 TEST_F(X11TopmostWindowFinderTest, Menu) {
   XID xid = CreateAndShowXWindow(gfx::Rect(100, 100, 100, 100));
 
   XID root = DefaultRootWindow(xdisplay());
   XSetWindowAttributes swa;
   swa.override_redirect = True;
   XID menu_xid = XCreateWindow(xdisplay(),
                                root,
                                0, 0, 1, 1,
                                0,                  // border width
                                CopyFromParent,     // depth
                                InputOutput,
                                CopyFromParent,     // visual
                                CWOverrideRedirect,
                                &swa);
   {
-    const char* kAtomsToCache[] = { "_NET_WM_WINDOW_TYPE_MENU", NULL };
+    const char* const kAtomsToCache[] = {"_NET_WM_WINDOW_TYPE_MENU", nullptr};
     ui::X11AtomCache atom_cache(gfx::GetXDisplay(), kAtomsToCache);
     ui::SetAtomProperty(menu_xid,
                         "_NET_WM_WINDOW_TYPE",
                         "ATOM",
                         atom_cache.GetAtom("_NET_WM_WINDOW_TYPE_MENU"));
   }
   ui::SetUseOSWindowFrame(menu_xid, false);
   ShowAndSetXWindowBounds(menu_xid, gfx::Rect(140, 110, 100, 100));
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   // |menu_xid| is never added to _NET_CLIENT_LIST_STACKING.
   XID xids[] = { xid };
   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
   stack_waiter.Wait();
 
   EXPECT_EQ(xid, FindTopmostXWindowAt(110, 110));
   EXPECT_EQ(menu_xid, FindTopmostXWindowAt(150, 120));
   EXPECT_EQ(menu_xid, FindTopmostXWindowAt(210, 120));
 
   XDestroyWindow(xdisplay(), xid);
   XDestroyWindow(xdisplay(), menu_xid);
 }
 
 }  // namespace views