Replace scoped_ptr with std::unique_ptr in //ui

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 <stddef.h>
-#include <X11/extensions/shape.h>
 #include <X11/Xlib.h>
 #include <X11/Xregion.h>
+#include <X11/extensions/shape.h>
+#include <stddef.h>
+
 #include <algorithm>
+#include <memory>
 #include <vector>
 
 // Get rid of X11 macros which conflict with gtest.
 #undef Bool
 #undef None
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_x11.h"
@@ skipping 25 matching lines @@
   bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<Atom> wm_states;
     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &wm_states)) {
       auto it = std::find(wm_states.cbegin(), wm_states.cend(),
                           atom_cache_->GetAtom("_NET_WM_STATE_HIDDEN"));
       return it == wm_states.cend();
     }
     return true;
   }
 
-  scoped_ptr<ui::X11AtomCache> atom_cache_;
+  std::unique_ptr<ui::X11AtomCache> atom_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(MinimizeWaiter);
 };
 
 // Waits till |_NET_CLIENT_LIST_STACKING| is updated to include
 // |expected_windows|.
 class StackingClientListWaiter : public X11PropertyChangeWaiter {
  public:
   StackingClientListWaiter(XID* expected_windows, size_t count)
       : X11PropertyChangeWaiter(ui::GetX11RootWindow(),
@@ skipping 35 matching lines @@
 
 class X11TopmostWindowFinderTest : public ViewsTestBase {
  public:
   X11TopmostWindowFinderTest() {
   }
 
   ~X11TopmostWindowFinderTest() override {}
 
   // Creates and shows a Widget with |bounds|. The caller takes ownership of
   // the returned widget.
-  scoped_ptr<Widget> CreateAndShowWidget(const gfx::Rect& bounds) {
-    scoped_ptr<Widget> toplevel(new Widget);
+  std::unique_ptr<Widget> CreateAndShowWidget(const gfx::Rect& bounds) {
+    std::unique_ptr<Widget> toplevel(new Widget);
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.native_widget = new DesktopNativeWidgetAura(toplevel.get());
     params.bounds = bounds;
     params.remove_standard_frame = true;
     toplevel->Init(params);
     toplevel->Show();
     return toplevel;
   }
 
@@ skipping 86 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(X11TopmostWindowFinderTest);
 };
 
 TEST_F(X11TopmostWindowFinderTest, Basic) {
   // Avoid positioning test windows at 0x0 because window managers often have a
   // panel/launcher along one of the screen edges and do not allow windows to
   // position themselves to overlap the panel/launcher.
-  scoped_ptr<Widget> widget1(
+  std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 200, 100)));
   aura::Window* window1 = widget1->GetNativeWindow();
   XID xid1 = window1->GetHost()->GetAcceleratedWidget();
 
   XID xid2 = CreateAndShowXWindow(gfx::Rect(200, 100, 100, 200));
 
-  scoped_ptr<Widget> widget3(
+  std::unique_ptr<Widget> widget3(
       CreateAndShowWidget(gfx::Rect(100, 190, 200, 110)));
   aura::Window* window3 = widget3->GetNativeWindow();
   XID xid3 = window3->GetHost()->GetAcceleratedWidget();
 
   XID xids[] = { xid1, xid2, xid3 };
   StackingClientListWaiter waiter(xids, arraysize(xids));
   waiter.Wait();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   EXPECT_EQ(xid1, FindTopmostXWindowAt(150, 150));
@@ skipping 23 matching lines @@
   EXPECT_EQ(NULL,
             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) {
-  scoped_ptr<Widget> widget1(
+  std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   aura::Window* window1 = widget1->GetNativeWindow();
   XID xid1 = window1->GetHost()->GetAcceleratedWidget();
   XID xid2 = CreateAndShowXWindow(gfx::Rect(300, 100, 100, 100));
 
   XID xids[] = { xid1, xid2 };
   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
   stack_waiter.Wait();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
@@ skipping 18 matching lines @@
   EXPECT_NE(xid2, FindTopmostXWindowAt(350, 150));
 
   XDestroyWindow(xdisplay(), xid2);
 }
 
 // Test that non-rectangular windows are properly handled.
 TEST_F(X11TopmostWindowFinderTest, NonRectangular) {
   if (!ui::IsShapeExtensionAvailable())
     return;
 
-  scoped_ptr<Widget> widget1(
+  std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   SkRegion* skregion1 = new 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);
 
   SkRegion skregion2;
   skregion2.op(SkIRect::MakeXYWH(0, 10, 10, 90), SkRegion::kUnion_Op);
@@ skipping 19 matching lines @@
   EXPECT_NE(xid2, FindTopmostXWindowAt(305, 105));
 
   XDestroyWindow(xdisplay(), xid2);
 }
 
 // Test that a window with an empty shape are properly handled.
 TEST_F(X11TopmostWindowFinderTest, NonRectangularEmptyShape) {
   if (!ui::IsShapeExtensionAvailable())
     return;
 
-  scoped_ptr<Widget> widget1(
+  std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   SkRegion* skregion1 = new SkRegion;
   skregion1->op(SkIRect::MakeXYWH(0, 0, 0, 0), SkRegion::kUnion_Op);
   // Widget takes ownership of |skregion1|.
   widget1->SetShape(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;
 
-  scoped_ptr<Widget> widget1(
+  std::unique_ptr<Widget> widget1(
       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   SkRegion* skregion1 = new SkRegion;
   skregion1->op(SkIRect::MakeXYWH(0, 0, 0, 0), SkRegion::kUnion_Op);
   // Widget takes ownership of |skregion1|.
   widget1->SetShape(skregion1);
 
   // Remove the shape - this is now just a normal window.
   widget1->SetShape(NULL);
 
@@ skipping 41 matching lines @@
 
   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