Replace scoped_ptr with std::unique_ptr in //ui

ui/views/widget/desktop_aura/desktop_window_tree_host_x11_unittest.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 <X11/Xlib.h>
+#include <X11/extensions/shape.h>
+#include <stddef.h>
+
+#include <memory>
 #include <vector>
 
-#include <stddef.h>
-#include <X11/extensions/shape.h>
-#include <X11/Xlib.h>
-
 // Get rid of X11 macros which conflict with gtest.
 // It is necessary to include this header before the rest so that Bool can be
 // undefined.
 #include "ui/events/test/events_test_utils_x11.h"
 #undef Bool
 #undef None
 
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
 #include "ui/events/platform/x11/x11_event_source_glib.h"
 #include "ui/events/test/platform_event_source_test_api.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 38 matching lines @@
     std::vector<Atom> hints;
     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &hints)) {
       auto it = std::find(hints.cbegin(), hints.cend(),
                           atom_cache_->GetAtom(hint_));
       bool hint_set = (it != hints.cend());
       return hint_set != wait_till_set_;
     }
     return true;
   }
 
-  scoped_ptr<ui::X11AtomCache> atom_cache_;
+  std::unique_ptr<ui::X11AtomCache> atom_cache_;
 
   // The name of the hint to wait to get set or unset.
   const char* hint_;
 
   // Whether we are waiting for |hint| to be set or unset.
   bool wait_till_set_;
 
   DISALLOW_COPY_AND_ASSIGN(WMStateWaiter);
 };
 
@@ skipping 43 matching lines @@
   // WidgetDelegateView:
   NonClientFrameView* CreateNonClientFrameView(Widget* widget) override {
     return new ShapedNonClientFrameView;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShapedWidgetDelegate);
 };
 
 // Creates a widget of size 100x100.
-scoped_ptr<Widget> CreateWidget(WidgetDelegate* delegate) {
-  scoped_ptr<Widget> widget(new Widget);
+std::unique_ptr<Widget> CreateWidget(WidgetDelegate* delegate) {
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.delegate = delegate;
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.remove_standard_frame = true;
   params.native_widget = new DesktopNativeWidgetAura(widget.get());
   params.bounds = gfx::Rect(100, 100, 100, 100);
   widget->Init(params);
   return widget;
 }
 
@@ skipping 57 matching lines @@
 };
 
 // Tests that the shape is properly set on the x window.
 TEST_F(DesktopWindowTreeHostX11Test, Shape) {
   if (!ui::IsShapeExtensionAvailable())
     return;
 
   // 1) Test setting the window shape via the NonClientFrameView. This technique
   // is used to get rounded corners on Chrome windows when not using the native
   // window frame.
-  scoped_ptr<Widget> widget1 = CreateWidget(new ShapedWidgetDelegate());
+  std::unique_ptr<Widget> widget1 = CreateWidget(new ShapedWidgetDelegate());
   widget1->Show();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   std::vector<gfx::Rect> shape_rects = GetShapeRects(xid1);
   ASSERT_FALSE(shape_rects.empty());
 
   // The widget was supposed to be 100x100, but the WM might have ignored this
   // suggestion.
   int widget_width = widget1->GetWindowBoundsInScreen().width();
@@ skipping 50 matching lines @@
   shape2.lineTo(10, 10);
   shape2.lineTo(0, 10);
   shape2.lineTo(0, 100);
   shape2.lineTo(100, 100);
   shape2.lineTo(100, 0);
   shape2.close();
 
   SkRegion* shape_region = new SkRegion;
   shape_region->setPath(shape2, SkRegion(shape2.getBounds().round()));
 
-  scoped_ptr<Widget> widget2(CreateWidget(NULL));
+  std::unique_ptr<Widget> widget2(CreateWidget(NULL));
   widget2->Show();
   widget2->SetShape(shape_region);
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   XID xid2 = widget2->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   shape_rects = GetShapeRects(xid2);
   ASSERT_FALSE(shape_rects.empty());
   EXPECT_FALSE(ShapeRectContainsPoint(shape_rects, 5, 5));
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 15, 5));
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 95, 15));
@@ skipping 19 matching lines @@
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 105, 15));
   EXPECT_FALSE(ShapeRectContainsPoint(shape_rects, 500, 500));
 }
 
 // Test that the widget ignores changes in fullscreen state initiated by the
 // window manager (e.g. via a window manager accelerator key).
 TEST_F(DesktopWindowTreeHostX11Test, WindowManagerTogglesFullscreen) {
   if (!ui::WmSupportsHint(ui::GetAtom("_NET_WM_STATE_FULLSCREEN")))
     return;
 
-  scoped_ptr<Widget> widget = CreateWidget(new ShapedWidgetDelegate());
+  std::unique_ptr<Widget> widget = CreateWidget(new ShapedWidgetDelegate());
   XID xid = widget->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   widget->Show();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   gfx::Rect initial_bounds = widget->GetWindowBoundsInScreen();
   {
     WMStateWaiter waiter(xid, "_NET_WM_STATE_FULLSCREEN", true);
     widget->SetFullscreen(true);
     waiter.Wait();
   }
@@ skipping 298 matching lines @@
   EXPECT_EQ(ui::ET_MOUSEWHEEL, second_recorder.mouse_events()[0].type());
   EXPECT_EQ(gfx::Point(-25, -25).ToString(),
             second_recorder.mouse_events()[0].location().ToString());
 
   PretendCapture(nullptr);
   first.GetNativeWindow()->RemovePreTargetHandler(&first_recorder);
   second.GetNativeWindow()->RemovePreTargetHandler(&second_recorder);
 }
 
 }  // namespace views