Replace scoped_ptr with std::unique_ptr in //ui

ui/views/widget/native_widget_aura_unittest.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/native_widget_aura.h"
 
+#include <memory>
+
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
@@ skipping 51 matching lines @@
   // testing::Test overrides:
   void SetUp() override {
     AuraTestBase::SetUp();
     test_focus_rules_ = new TestFocusRules;
     focus_controller_.reset(new wm::FocusController(test_focus_rules_));
     aura::client::SetActivationClient(root_window(), focus_controller_.get());
     host()->SetBounds(gfx::Rect(640, 480));
   }
 
  private:
-  scoped_ptr<wm::FocusController> focus_controller_;
+  std::unique_ptr<wm::FocusController> focus_controller_;
   TestFocusRules* test_focus_rules_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetAuraTest);
 };
 
 TEST_F(NativeWidgetAuraTest, CenterWindowLargeParent) {
   // Make a parent window larger than the host represented by
   // WindowEventDispatcher.
-  scoped_ptr<aura::Window> parent(new aura::Window(NULL));
+  std::unique_ptr<aura::Window> parent(new aura::Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   parent->SetBounds(gfx::Rect(0, 0, 1024, 800));
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   NativeWidgetAura* window = Init(parent.get(), widget.get());
 
   window->CenterWindow(gfx::Size(100, 100));
   EXPECT_EQ(gfx::Rect( (640 - 100) / 2,
                        (480 - 100) / 2,
                        100, 100),
             window->GetNativeWindow()->bounds());
   widget->CloseNow();
 }
 
 TEST_F(NativeWidgetAuraTest, CenterWindowSmallParent) {
   // Make a parent window smaller than the host represented by
   // WindowEventDispatcher.
-  scoped_ptr<aura::Window> parent(new aura::Window(NULL));
+  std::unique_ptr<aura::Window> parent(new aura::Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   parent->SetBounds(gfx::Rect(0, 0, 480, 320));
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   NativeWidgetAura* window = Init(parent.get(), widget.get());
 
   window->CenterWindow(gfx::Size(100, 100));
   EXPECT_EQ(gfx::Rect( (480 - 100) / 2,
                        (320 - 100) / 2,
                        100, 100),
             window->GetNativeWindow()->bounds());
   widget->CloseNow();
 }
 
 // Verifies CenterWindow() constrains to parent size.
 TEST_F(NativeWidgetAuraTest, CenterWindowSmallParentNotAtOrigin) {
   // Make a parent window smaller than the host represented by
   // WindowEventDispatcher and offset it slightly from the origin.
-  scoped_ptr<aura::Window> parent(new aura::Window(NULL));
+  std::unique_ptr<aura::Window> parent(new aura::Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   parent->SetBounds(gfx::Rect(20, 40, 480, 320));
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   NativeWidgetAura* window = Init(parent.get(), widget.get());
   window->CenterWindow(gfx::Size(500, 600));
 
   // |window| should be no bigger than |parent|.
   EXPECT_EQ("20,40 480x320", window->GetNativeWindow()->bounds().ToString());
   widget->CloseNow();
 }
 
 TEST_F(NativeWidgetAuraTest, CreateMinimized) {
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = NULL;
   params.context = root_window();
   params.show_state = ui::SHOW_STATE_MINIMIZED;
   params.bounds.SetRect(0, 0, 1024, 800);
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   widget->Init(params);
   widget->Show();
 
   EXPECT_TRUE(widget->IsMinimized());
   widget->CloseNow();
 }
 
 class TestLayoutManagerBase : public aura::LayoutManager {
  public:
   TestLayoutManagerBase() {}
@@ skipping 57 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestWidget);
 };
 
 // Verifies the size of the widget doesn't change more than once during Init if
 // the window ends up maximized. This is important as otherwise
 // RenderWidgetHostViewAura ends up getting resized during construction, which
 // leads to noticable flashes.
 TEST_F(NativeWidgetAuraTest, ShowMaximizedDoesntBounceAround) {
   root_window()->SetBounds(gfx::Rect(0, 0, 640, 480));
   root_window()->SetLayoutManager(new MaximizeLayoutManager);
-  scoped_ptr<TestWidget> widget(new TestWidget());
+  std::unique_ptr<TestWidget> widget(new TestWidget());
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = NULL;
   params.context = root_window();
   params.show_state = ui::SHOW_STATE_MAXIMIZED;
   params.bounds = gfx::Rect(10, 10, 100, 200);
   widget->Init(params);
   EXPECT_FALSE(widget->did_size_change_more_than_once());
   widget->CloseNow();
 }
@@ skipping 36 matching lines @@
   Widget* widget_;
   DISALLOW_COPY_AND_ASSIGN(PropertyTestWidgetDelegate);
 };
 
 // Verifies that the kCanMaximizeKey/kCanMinimizeKey/kCanResizeKey have the
 // correct value when added to the layout manager.
 TEST_F(NativeWidgetAuraTest, TestPropertiesWhenAddedToLayout) {
   root_window()->SetBounds(gfx::Rect(0, 0, 640, 480));
   PropertyTestLayoutManager* layout_manager = new PropertyTestLayoutManager();
   root_window()->SetLayoutManager(layout_manager);
-  scoped_ptr<TestWidget> widget(new TestWidget());
+  std::unique_ptr<TestWidget> widget(new TestWidget());
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = new PropertyTestWidgetDelegate(widget.get());
   params.parent = NULL;
   params.context = root_window();
   widget->Init(params);
   EXPECT_TRUE(layout_manager->added());
   widget->CloseNow();
 }
 
 TEST_F(NativeWidgetAuraTest, GetClientAreaScreenBounds) {
   // Create a widget.
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.context = root_window();
   params.bounds.SetRect(10, 20, 300, 400);
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   widget->Init(params);
 
   // For Aura, client area bounds match window bounds.
   gfx::Rect client_bounds = widget->GetClientAreaBoundsInScreen();
   EXPECT_EQ(10, client_bounds.x());
   EXPECT_EQ(20, client_bounds.y());
   EXPECT_EQ(300, client_bounds.width());
   EXPECT_EQ(400, client_bounds.height());
 }
 
@@ skipping 35 matching lines @@
 // Verifies a capture isn't set on touch press and that the view that gets
 // the press gets the release.
 TEST_F(NativeWidgetAuraTest, DontCaptureOnGesture) {
   // Create two views (both sized the same). |child| is configured not to
   // consume the gesture event.
   GestureTrackingView* view = new GestureTrackingView();
   GestureTrackingView* child = new GestureTrackingView();
   child->set_consume_gesture_event(false);
   view->SetLayoutManager(new FillLayout);
   view->AddChildView(child);
-  scoped_ptr<TestWidget> widget(new TestWidget());
+  std::unique_ptr<TestWidget> widget(new TestWidget());
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.context = root_window();
   params.bounds = gfx::Rect(0, 0, 100, 200);
   widget->Init(params);
   widget->SetContentsView(view);
   widget->Show();
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(41, 51), 1, ui::EventTimeForNow());
@@ skipping 20 matching lines @@
 
   // Work around for bug in NativeWidgetAura.
   // TODO: fix bug and remove this.
   widget->Close();
 }
 
 // Verifies views with layers are targeted for events properly.
 TEST_F(NativeWidgetAuraTest, PreferViewLayersToChildWindows) {
   // Create two widgets: |parent| and |child|. |child| is a child of |parent|.
   views::View* parent_root = new views::View;
-  scoped_ptr<Widget> parent(new Widget());
+  std::unique_ptr<Widget> parent(new Widget());
   Widget::InitParams parent_params(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   parent_params.ownership =
       views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   parent_params.context = root_window();
   parent->Init(parent_params);
   parent->SetContentsView(parent_root);
   parent->SetBounds(gfx::Rect(0, 0, 400, 400));
   parent->Show();
 
-  scoped_ptr<Widget> child(new Widget());
+  std::unique_ptr<Widget> child(new Widget());
   Widget::InitParams child_params(Widget::InitParams::TYPE_CONTROL);
   child_params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   child_params.parent = parent->GetNativeWindow();
   child->Init(child_params);
   child->SetBounds(gfx::Rect(0, 0, 200, 200));
   child->Show();
 
   // Point is over |child|.
   EXPECT_EQ(child->GetNativeWindow(),
             parent->GetNativeWindow()->GetEventHandlerForPoint(
@@ skipping 31 matching lines @@
                 gfx::Point(20, 20)));
 
   // Work around for bug in NativeWidgetAura.
   // TODO: fix bug and remove this.
   parent->Close();
 }
 
 // Verifies that widget->FlashFrame() sets aura::client::kDrawAttentionKey,
 // and activating the window clears it.
 TEST_F(NativeWidgetAuraTest, FlashFrame) {
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.context = root_window();
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
   aura::Window* window = widget->GetNativeWindow();
   EXPECT_FALSE(window->GetProperty(aura::client::kDrawAttentionKey));
   widget->FlashFrame(true);
   EXPECT_TRUE(window->GetProperty(aura::client::kDrawAttentionKey));
   widget->FlashFrame(false);
   EXPECT_FALSE(window->GetProperty(aura::client::kDrawAttentionKey));
   widget->FlashFrame(true);
   EXPECT_TRUE(window->GetProperty(aura::client::kDrawAttentionKey));
   widget->Activate();
   EXPECT_FALSE(window->GetProperty(aura::client::kDrawAttentionKey));
 }
 
 TEST_F(NativeWidgetAuraTest, NoCrashOnThemeAfterClose) {
-  scoped_ptr<aura::Window> parent(new aura::Window(NULL));
+  std::unique_ptr<aura::Window> parent(new aura::Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   parent->SetBounds(gfx::Rect(0, 0, 480, 320));
-  scoped_ptr<Widget> widget(new Widget());
+  std::unique_ptr<Widget> widget(new Widget());
   Init(parent.get(), widget.get());
   widget->Show();
   widget->Close();
   base::MessageLoop::current()->RunUntilIdle();
   widget->GetNativeTheme();  // Shouldn't crash.
 }
 
 // Used to track calls to WidgetDelegate::OnWidgetMove().
 class MoveTestWidgetDelegate : public WidgetDelegateView {
  public:
@@ skipping 42 matching lines @@
   EXPECT_FALSE(delegate.view()->HasFocus());
 
   test_focus_rules()->set_can_activate(true);
   views::test::TestInitialFocusWidgetDelegate delegate2(root_window());
   delegate2.GetWidget()->Show();
   EXPECT_TRUE(delegate2.view()->HasFocus());
 }
 
 }  // namespace
 }  // namespace views