Replace scoped_ptr with std::unique_ptr in //ui

ui/views/view_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/view.h"
+
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 10 matching lines @@
 #include "ui/gfx/path.h"
 #include "ui/gfx/transform.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/native/native_view_host.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/test/views_test_base.h"
-#include "ui/views/view.h"
 #include "ui/views/widget/native_widget.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/window/dialog_client_view.h"
 #include "ui/views/window/dialog_delegate.h"
 
 using base::ASCIIToUTF16;
 
 namespace {
 
 // Returns true if |ancestor| is an ancestor of |layer|.
@@ skipping 325 matching lines @@
   received_mouse_exit_ = true;
 }
 
 TEST_F(ViewTest, MouseEvent) {
   TestView* v1 = new TestView();
   v1->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
   TestView* v2 = new TestView();
   v2->SetBoundsRect(gfx::Rect(100, 100, 100, 100));
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(50, 50, 650, 650);
   widget->Init(params);
   internal::RootView* root =
       static_cast<internal::RootView*>(widget->GetRootView());
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
@@ skipping 42 matching lines @@
 TEST_F(ViewTest, DeleteOnPressed) {
   TestView* v1 = new TestView();
   v1->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
   TestView* v2 = new TestView();
   v2->SetBoundsRect(gfx::Rect(100, 100, 100, 100));
 
   v1->Reset();
   v2->Reset();
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(50, 50, 650, 650);
   widget->Init(params);
   View* root = widget->GetRootView();
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
   v2->delete_on_pressed_ = true;
@@ skipping 1644 matching lines @@
 // handle accelerators or not (see View::CanHandleAccelerators for details).
 // This test targets that extra logic, but should also work on other platforms.
 TEST_F(ViewTest, HandleAccelerator) {
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 0);
 
   // Create a window and add the view as its child.
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 100, 100);
   widget->Init(params);
   View* root = widget->GetRootView();
   root->AddChildView(view);
   widget->Show();
 
   FocusManager* focus_manager = widget->GetFocusManager();
   ASSERT_TRUE(focus_manager);
@@ skipping 58 matching lines @@
 #if 0
 TEST_F(ViewTest, ActivateAccelerator) {
   // Register a keyboard accelerator before the view is added to a window.
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 0);
 
   // Create a window and add the view as its child.
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 100, 100);
   widget->Init(params);
   View* root = widget->GetRootView();
   root->AddChildView(view);
   widget->Show();
 
   // Get the focus manager.
   FocusManager* focus_manager = widget->GetFocusManager();
@@ skipping 42 matching lines @@
   widget->CloseNow();
 }
 
 TEST_F(ViewTest, HiddenViewWithAccelerator) {
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 0);
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 100, 100);
   widget->Init(params);
   View* root = widget->GetRootView();
   root->AddChildView(view);
   widget->Show();
 
   FocusManager* focus_manager = widget->GetFocusManager();
   ASSERT_TRUE(focus_manager);
 
   view->SetVisible(false);
   EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
 
   view->SetVisible(true);
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
 
   widget->CloseNow();
 }
 
 TEST_F(ViewTest, ViewInHiddenWidgetWithAccelerator) {
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 0);
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 100, 100);
   widget->Init(params);
   View* root = widget->GetRootView();
   root->AddChildView(view);
 
   FocusManager* focus_manager = widget->GetFocusManager();
   ASSERT_TRUE(focus_manager);
 
@@ skipping 125 matching lines @@
 // No ReparentNativeView on Mac. See http://crbug.com/514920.
 #if defined(OS_MACOSX) && !defined(USE_AURA)
 #define MAYBE_NativeViewHierarchyChanged DISABLED_NativeViewHierarchyChanged
 #else
 #define MAYBE_NativeViewHierarchyChanged NativeViewHierarchyChanged
 #endif
 
 // Test that a view can track the current top level widget by overriding
 // View::ViewHierarchyChanged() and View::NativeViewHierarchyChanged().
 TEST_F(ViewTest, MAYBE_NativeViewHierarchyChanged) {
-  scoped_ptr<Widget> toplevel1(new Widget);
+  std::unique_ptr<Widget> toplevel1(new Widget);
   Widget::InitParams toplevel1_params =
       CreateParams(Widget::InitParams::TYPE_POPUP);
   toplevel1_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   toplevel1->Init(toplevel1_params);
 
-  scoped_ptr<Widget> toplevel2(new Widget);
+  std::unique_ptr<Widget> toplevel2(new Widget);
   Widget::InitParams toplevel2_params =
       CreateParams(Widget::InitParams::TYPE_POPUP);
   toplevel2_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   toplevel2->Init(toplevel2_params);
 
   Widget* child = new Widget;
   Widget::InitParams child_params(Widget::InitParams::TYPE_CONTROL);
   child_params.parent = toplevel1->GetNativeView();
   child->Init(child_params);
 
@@ skipping 220 matching lines @@
   EXPECT_EQ(25, v3->location_.y());
 
   root->OnMouseReleased(released);
 
   widget->CloseNow();
 }
 
 TEST_F(ViewTest, TransformVisibleBound) {
   gfx::Rect viewport_bounds(0, 0, 100, 100);
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = viewport_bounds;
   widget->Init(params);
   widget->GetRootView()->SetBoundsRect(viewport_bounds);
 
   View* viewport = new View;
   widget->SetContentsView(viewport);
   View* contents = new View;
   viewport->AddChildView(contents);
@@ skipping 36 matching lines @@
   void OnVisibleBoundsChanged() override { received_notification_ = true; }
 
   bool received_notification_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibleBoundsView);
 };
 
 TEST_F(ViewTest, OnVisibleBoundsChanged) {
   gfx::Rect viewport_bounds(0, 0, 100, 100);
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = viewport_bounds;
   widget->Init(params);
   widget->GetRootView()->SetBoundsRect(viewport_bounds);
 
   View* viewport = new View;
   widget->SetContentsView(viewport);
   View* contents = new View;
   viewport->AddChildView(contents);
@@ skipping 81 matching lines @@
   view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
   EXPECT_TRUE(view.scheduled_paint_rects_.empty());
 }
 
 // Verifies AddChildView() and RemoveChildView() schedule appropriate paints.
 TEST_F(ViewTest, AddAndRemoveSchedulePaints) {
   gfx::Rect viewport_bounds(0, 0, 100, 100);
 
   // We have to put the View hierarchy into a Widget or no paints will be
   // scheduled.
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = viewport_bounds;
   widget->Init(params);
   widget->GetRootView()->SetBoundsRect(viewport_bounds);
 
   TestView* parent_view = new TestView;
   widget->SetContentsView(parent_view);
   parent_view->SetBoundsRect(viewport_bounds);
   parent_view->scheduled_paint_rects_.clear();
 
   View* child_view = new View;
   child_view->SetBoundsRect(gfx::Rect(0, 0, 20, 20));
   parent_view->AddChildView(child_view);
   ASSERT_EQ(1U, parent_view->scheduled_paint_rects_.size());
   EXPECT_EQ(child_view->bounds(), parent_view->scheduled_paint_rects_.front());
 
   parent_view->scheduled_paint_rects_.clear();
   parent_view->RemoveChildView(child_view);
-  scoped_ptr<View> child_deleter(child_view);
+  std::unique_ptr<View> child_deleter(child_view);
   ASSERT_EQ(1U, parent_view->scheduled_paint_rects_.size());
   EXPECT_EQ(child_view->bounds(), parent_view->scheduled_paint_rects_.front());
 
   widget->CloseNow();
 }
 
 // Tests conversion methods with a transform.
 TEST_F(ViewTest, ConversionsWithTransform) {
   TestView top_view;
 
@@ skipping 175 matching lines @@
     View::ConvertRectToTarget(&top_view, child_2, &rect);
     EXPECT_FLOAT_EQ(50.0f, rect.x());
     EXPECT_FLOAT_EQ(55.0f, rect.y());
     EXPECT_FLOAT_EQ(20.0f, rect.width());
     EXPECT_FLOAT_EQ(30.0f, rect.height());
   }
 }
 
 // Tests conversion methods to and from screen coordinates.
 TEST_F(ViewTest, ConversionsToFromScreen) {
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(50, 50, 650, 650);
   widget->Init(params);
 
   View* child = new View;
   widget->GetRootView()->AddChildView(child);
   child->SetBounds(10, 10, 100, 200);
   gfx::Transform t;
   t.Scale(0.5, 0.5);
   child->SetTransform(t);
 
   gfx::Point point_in_screen(100, 90);
   gfx::Point point_in_child(80, 60);
 
   gfx::Point point = point_in_screen;
   View::ConvertPointFromScreen(child, &point);
   EXPECT_EQ(point_in_child.ToString(), point.ToString());
 
   View::ConvertPointToScreen(child, &point);
   EXPECT_EQ(point_in_screen.ToString(), point.ToString());
 }
 
 // Tests conversion methods for rectangles.
 TEST_F(ViewTest, ConvertRectWithTransform) {
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(50, 50, 650, 650);
   widget->Init(params);
   View* root = widget->GetRootView();
 
   TestView* v1 = new TestView;
   TestView* v2 = new TestView;
   root->AddChildView(v1);
   v1->AddChildView(v2);
@@ skipping 94 matching lines @@
 // v1
 // +-- v2
 //     +-- v3
 //     +-- v4 (starts here, then get reparented to v1)
 TEST_F(ViewTest, ViewHierarchyChanged) {
   ObserverView v1;
 
   ObserverView* v3 = new ObserverView();
 
   // Add |v3| to |v2|.
-  scoped_ptr<ObserverView> v2(new ObserverView());
+  std::unique_ptr<ObserverView> v2(new ObserverView());
   v2->AddChildView(v3);
 
   // Make sure both |v2| and |v3| receive the ViewHierarchyChanged()
   // notification.
   EXPECT_TRUE(v2->has_add_details());
   EXPECT_FALSE(v2->has_remove_details());
   EXPECT_EQ(v2.get(), v2->add_details().parent);
   EXPECT_EQ(v3, v2->add_details().child);
   EXPECT_EQ(NULL, v2->add_details().move_view);
 
@@ skipping 994 matching lines @@
   // Move c1 to the front. The layers should have moved too.
   content->ReorderChildView(c1, -1);
   EXPECT_EQ(c1->layer(), parent_layer->children()[1]);
   EXPECT_EQ(c2->layer(), parent_layer->children()[0]);
 }
 
 // Verifies that the layer of a view can be acquired properly.
 TEST_F(ViewLayerTest, AcquireLayer) {
   View* content = new View;
   widget()->SetContentsView(content);
-  scoped_ptr<View> c1(new View);
+  std::unique_ptr<View> c1(new View);
   c1->SetPaintToLayer(true);
   EXPECT_TRUE(c1->layer());
   content->AddChildView(c1.get());
 
-  scoped_ptr<ui::Layer> layer(c1->AcquireLayer());
+  std::unique_ptr<ui::Layer> layer(c1->AcquireLayer());
   EXPECT_EQ(layer.get(), c1->layer());
 
-  scoped_ptr<ui::Layer> layer2(c1->RecreateLayer());
+  std::unique_ptr<ui::Layer> layer2(c1->RecreateLayer());
   EXPECT_NE(c1->layer(), layer2.get());
 
   // Destroy view before destroying layer.
   c1.reset();
 }
 
 // Verify the z-order of the layers as a result of calling RecreateLayer().
 TEST_F(ViewLayerTest, RecreateLayerZOrder) {
-  scoped_ptr<View> v(new View());
+  std::unique_ptr<View> v(new View());
   v->SetPaintToLayer(true);
 
   View* v1 = new View();
   v1->SetPaintToLayer(true);
   v->AddChildView(v1);
   View* v2 = new View();
   v2->SetPaintToLayer(true);
   v->AddChildView(v2);
 
   // Test the initial z-order.
   const std::vector<ui::Layer*>& child_layers_pre = v->layer()->children();
   ASSERT_EQ(2u, child_layers_pre.size());
   EXPECT_EQ(v1->layer(), child_layers_pre[0]);
   EXPECT_EQ(v2->layer(), child_layers_pre[1]);
 
-  scoped_ptr<ui::Layer> v1_old_layer(v1->RecreateLayer());
+  std::unique_ptr<ui::Layer> v1_old_layer(v1->RecreateLayer());
 
   // Test the new layer order. We expect: |v1| |v1_old_layer| |v2|.
   // for |v1| and |v2|.
   const std::vector<ui::Layer*>& child_layers_post = v->layer()->children();
   ASSERT_EQ(3u, child_layers_post.size());
   EXPECT_EQ(v1->layer(), child_layers_post[0]);
   EXPECT_EQ(v1_old_layer.get(), child_layers_post[1]);
   EXPECT_EQ(v2->layer(), child_layers_post[2]);
 }
 
@@ skipping 11 matching lines @@
   v->AddChildView(v2);
 
   ui::Layer* root_layer = GetRootLayer();
 
   // Test the initial z-order.
   const std::vector<ui::Layer*>& child_layers_pre = root_layer->children();
   ASSERT_EQ(2u, child_layers_pre.size());
   EXPECT_EQ(v1->layer(), child_layers_pre[0]);
   EXPECT_EQ(v2->layer(), child_layers_pre[1]);
 
-  scoped_ptr<ui::Layer> v1_old_layer(v1->RecreateLayer());
+  std::unique_ptr<ui::Layer> v1_old_layer(v1->RecreateLayer());
 
   // Test the new layer order. We expect: |v1| |v1_old_layer| |v2|.
   const std::vector<ui::Layer*>& child_layers_post = root_layer->children();
   ASSERT_EQ(3u, child_layers_post.size());
   EXPECT_EQ(v1->layer(), child_layers_post[0]);
   EXPECT_EQ(v1_old_layer.get(), child_layers_post[1]);
   EXPECT_EQ(v2->layer(), child_layers_post[2]);
 }
 
 // Verifies RecreateLayer() moves all Layers over, even those that don't have
 // a View.
 TEST_F(ViewLayerTest, RecreateLayerMovesNonViewChildren) {
   View v;
   v.SetPaintToLayer(true);
   View child;
   child.SetPaintToLayer(true);
   v.AddChildView(&child);
   ASSERT_TRUE(v.layer() != NULL);
   ASSERT_EQ(1u, v.layer()->children().size());
   EXPECT_EQ(v.layer()->children()[0], child.layer());
 
   ui::Layer layer(ui::LAYER_NOT_DRAWN);
   v.layer()->Add(&layer);
   v.layer()->StackAtBottom(&layer);
 
-  scoped_ptr<ui::Layer> old_layer(v.RecreateLayer());
+  std::unique_ptr<ui::Layer> old_layer(v.RecreateLayer());
 
   // All children should be moved from old layer to new layer.
   ASSERT_TRUE(old_layer.get() != NULL);
   EXPECT_TRUE(old_layer->children().empty());
 
   // And new layer should have the two children.
   ASSERT_TRUE(v.layer() != NULL);
   ASSERT_EQ(2u, v.layer()->children().size());
   EXPECT_EQ(v.layer()->children()[0], &layer);
   EXPECT_EQ(v.layer()->children()[1], child.layer());
@@ skipping 85 matching lines @@
 TEST_F(ViewTest, OnNativeThemeChanged) {
   TestView* test_view = new TestView();
   EXPECT_FALSE(test_view->native_theme_);
   TestView* test_view_child = new TestView();
   EXPECT_FALSE(test_view_child->native_theme_);
 
   // Child view added before the widget hierarchy exists should get the
   // new native theme notification.
   test_view->AddChildView(test_view_child);
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
 
   widget->GetRootView()->AddChildView(test_view);
   EXPECT_TRUE(test_view->native_theme_);
   EXPECT_EQ(widget->GetNativeTheme(), test_view->native_theme_);
   EXPECT_TRUE(test_view_child->native_theme_);
   EXPECT_EQ(widget->GetNativeTheme(), test_view_child->native_theme_);
 
@@ skipping 19 matching lines @@
   }
 
   TestView* view_;
   bool had_mouse_event_;
 };
 
 TEST_F(ViewTest, ScopedTargetHandlerReceivesEvents) {
   TestView* v = new TestView();
   v->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
-  scoped_ptr<Widget> widget(new Widget);
+  std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(50, 50, 350, 350);
   widget->Init(params);
   View* root = widget->GetRootView();
   root->AddChildView(v);
   v->Reset();
   {
     TestEventHandler handler(v);
     ui::ScopedTargetHandler scoped_target_handler(v, &handler);
@@ skipping 106 matching lines @@
   widget.Init(params);
 
   AddViewWithChildLayer(widget.GetRootView());
   ViewThatAddsViewInOnNativeThemeChanged* v =
       new ViewThatAddsViewInOnNativeThemeChanged;
   widget.GetRootView()->AddChildView(v);
   EXPECT_TRUE(v->on_native_theme_changed_called());
 }
 
 }  // namespace views