Replace scoped_ptr with std::unique_ptr in //ui

ui/wm/core/image_grid_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/wm/core/image_grid.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/gfx/image/image.h"
@@ skipping 13 matching lines @@
 }  // namespace
 
 typedef aura::test::AuraTestBase ImageGridTest;
 
 // Test that an ImageGrid's layers are transformed correctly when SetSize() is
 // called.
 TEST_F(ImageGridTest, Basic) {
   // Size of the images around the grid's border.
   const int kBorder = 2;
 
-  scoped_ptr<gfx::Image> image_1x1(CreateImage(gfx::Size(1, 1)));
-  scoped_ptr<gfx::Image> image_1xB(CreateImage(gfx::Size(1, kBorder)));
-  scoped_ptr<gfx::Image> image_Bx1(CreateImage(gfx::Size(kBorder, 1)));
-  scoped_ptr<gfx::Image> image_BxB(CreateImage(gfx::Size(kBorder, kBorder)));
+  std::unique_ptr<gfx::Image> image_1x1(CreateImage(gfx::Size(1, 1)));
+  std::unique_ptr<gfx::Image> image_1xB(CreateImage(gfx::Size(1, kBorder)));
+  std::unique_ptr<gfx::Image> image_Bx1(CreateImage(gfx::Size(kBorder, 1)));
+  std::unique_ptr<gfx::Image> image_BxB(
+      CreateImage(gfx::Size(kBorder, kBorder)));
 
   ImageGrid grid;
   grid.SetImages(image_BxB.get(), image_1xB.get(), image_BxB.get(),
                  image_Bx1.get(), image_1x1.get(), image_Bx1.get(),
                  image_BxB.get(), image_1xB.get(), image_BxB.get());
 
   ImageGrid::TestAPI test_api(&grid);
   ASSERT_TRUE(grid.top_left_layer() != NULL);
   ASSERT_TRUE(grid.top_layer() != NULL);
   ASSERT_TRUE(grid.top_right_layer() != NULL);
@@ skipping 68 matching lines @@
             test_api.GetTransformedLayerBounds(
                 *grid.bottom_right_layer()).ToString());
 }
 
 // Test that an ImageGrid's layers are transformed correctly when
 // SetContentBounds() is called.
 TEST_F(ImageGridTest, SetContentBounds) {
   // Size of the images around the grid's border.
   const int kBorder = 2;
 
-  scoped_ptr<gfx::Image> image_1x1(CreateImage(gfx::Size(1, 1)));
-  scoped_ptr<gfx::Image> image_1xB(CreateImage(gfx::Size(1, kBorder)));
-  scoped_ptr<gfx::Image> image_Bx1(CreateImage(gfx::Size(kBorder, 1)));
-  scoped_ptr<gfx::Image> image_BxB(CreateImage(gfx::Size(kBorder, kBorder)));
+  std::unique_ptr<gfx::Image> image_1x1(CreateImage(gfx::Size(1, 1)));
+  std::unique_ptr<gfx::Image> image_1xB(CreateImage(gfx::Size(1, kBorder)));
+  std::unique_ptr<gfx::Image> image_Bx1(CreateImage(gfx::Size(kBorder, 1)));
+  std::unique_ptr<gfx::Image> image_BxB(
+      CreateImage(gfx::Size(kBorder, kBorder)));
 
   ImageGrid grid;
   grid.SetImages(image_BxB.get(), image_1xB.get(), image_BxB.get(),
                  image_Bx1.get(), image_1x1.get(), image_Bx1.get(),
                  image_BxB.get(), image_1xB.get(), image_BxB.get());
 
   ImageGrid::TestAPI test_api(&grid);
 
   const gfx::Point origin(5, 10);
   const gfx::Size size(20, 30);
   grid.SetContentBounds(gfx::Rect(origin, size));
 
   // The master layer is positioned above the top-left corner of the content
   // bounds and has height/width that contain the grid and bounds.
   EXPECT_EQ(gfx::RectF(origin.x() - kBorder,
                       origin.y() - kBorder,
                       size.width() + 2 * kBorder,
                       size.height() + 2 * kBorder).ToString(),
             test_api.GetTransformedLayerBounds(*grid.layer()).ToString());
 }
 
 // Check that we don't crash if only a single image is supplied.
 TEST_F(ImageGridTest, SingleImage) {
   const int kBorder = 1;
-  scoped_ptr<gfx::Image> image(CreateImage(gfx::Size(kBorder, kBorder)));
+  std::unique_ptr<gfx::Image> image(CreateImage(gfx::Size(kBorder, kBorder)));
 
   ImageGrid grid;
   grid.SetImages(NULL, image.get(), NULL,
                  NULL, NULL, NULL,
                  NULL, NULL, NULL);
 
   ImageGrid::TestAPI test_api(&grid);
   EXPECT_TRUE(grid.top_left_layer() == NULL);
   ASSERT_TRUE(grid.top_layer() != NULL);
   EXPECT_TRUE(grid.top_right_layer() == NULL);
@@ skipping 11 matching lines @@
   // shouldn't be scaled vertically.
   EXPECT_EQ(gfx::RectF(0, 0, kSize.width(), kBorder).ToString(),
             test_api.GetTransformedLayerBounds(
                 *grid.top_layer()).ToString());
 }
 
 // Check that we don't crash when we reset existing images to NULL and
 // reset NULL images to new ones.
 TEST_F(ImageGridTest, ResetImages) {
   const int kBorder = 1;
-  scoped_ptr<gfx::Image> image(CreateImage(gfx::Size(kBorder, kBorder)));
+  std::unique_ptr<gfx::Image> image(CreateImage(gfx::Size(kBorder, kBorder)));
 
   ImageGrid grid;
   grid.SetImages(NULL, image.get(), NULL,
                  NULL, NULL, NULL,
                  NULL, NULL, NULL);
 
   // Only the top edge has a layer.
   ImageGrid::TestAPI test_api(&grid);
   ASSERT_TRUE(grid.top_left_layer() == NULL);
   ASSERT_FALSE(grid.top_layer() == NULL);
@@ skipping 21 matching lines @@
   ASSERT_TRUE(grid.bottom_right_layer() == NULL);
 }
 
 // Test that side (top, left, right, bottom) layers that are narrower than their
 // adjacent corner layers stay pinned to the outside edges instead of getting
 // moved inwards or scaled.  This exercises the scenario used for shadows.
 TEST_F(ImageGridTest, SmallerSides) {
   const int kCorner = 2;
   const int kEdge = 1;
 
-  scoped_ptr<gfx::Image> top_left_image(
+  std::unique_ptr<gfx::Image> top_left_image(
       CreateImage(gfx::Size(kCorner, kCorner)));
-  scoped_ptr<gfx::Image> top_image(CreateImage(gfx::Size(kEdge, kEdge)));
-  scoped_ptr<gfx::Image> top_right_image(
+  std::unique_ptr<gfx::Image> top_image(CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> top_right_image(
       CreateImage(gfx::Size(kCorner, kCorner)));
-  scoped_ptr<gfx::Image> left_image(CreateImage(gfx::Size(kEdge, kEdge)));
-  scoped_ptr<gfx::Image> right_image(CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> left_image(CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> right_image(CreateImage(gfx::Size(kEdge, kEdge)));
 
   ImageGrid grid;
   grid.SetImages(top_left_image.get(), top_image.get(), top_right_image.get(),
                  left_image.get(), NULL, right_image.get(),
                  NULL, NULL, NULL);
   ImageGrid::TestAPI test_api(&grid);
 
   const gfx::Size kSize(20, 30);
   grid.SetSize(kSize);
 
@@ skipping 20 matching lines @@
                 *grid.right_layer()).ToString());
 }
 
 // Test that we hide or clip layers as needed when the grid is assigned a small
 // size.
 TEST_F(ImageGridTest, TooSmall) {
   const int kCorner = 5;
   const int kCenter = 3;
   const int kEdge = 3;
 
-  scoped_ptr<gfx::Image> top_left_image(
+  std::unique_ptr<gfx::Image> top_left_image(
       CreateImage(gfx::Size(kCorner, kCorner)));
-  scoped_ptr<gfx::Image> top_image(CreateImage(gfx::Size(kEdge, kEdge)));
-  scoped_ptr<gfx::Image> top_right_image(
+  std::unique_ptr<gfx::Image> top_image(CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> top_right_image(
       CreateImage(gfx::Size(kCorner, kCorner)));
-  scoped_ptr<gfx::Image> left_image(CreateImage(gfx::Size(kEdge, kEdge)));
-  scoped_ptr<gfx::Image> center_image(CreateImage(gfx::Size(kCenter, kCenter)));
-  scoped_ptr<gfx::Image> right_image(CreateImage(gfx::Size(kEdge, kEdge)));
-  scoped_ptr<gfx::Image> bottom_left_image(
+  std::unique_ptr<gfx::Image> left_image(CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> center_image(
+      CreateImage(gfx::Size(kCenter, kCenter)));
+  std::unique_ptr<gfx::Image> right_image(CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> bottom_left_image(
       CreateImage(gfx::Size(kCorner, kCorner)));
-  scoped_ptr<gfx::Image> bottom_image(CreateImage(gfx::Size(kEdge, kEdge)));
-  scoped_ptr<gfx::Image> bottom_right_image(
+  std::unique_ptr<gfx::Image> bottom_image(
+      CreateImage(gfx::Size(kEdge, kEdge)));
+  std::unique_ptr<gfx::Image> bottom_right_image(
       CreateImage(gfx::Size(kCorner, kCorner)));
 
   ImageGrid grid;
   grid.SetImages(
       top_left_image.get(), top_image.get(), top_right_image.get(),
       left_image.get(), center_image.get(), right_image.get(),
       bottom_left_image.get(), bottom_image.get(), bottom_right_image.get());
   ImageGrid::TestAPI test_api(&grid);
 
   // Set a size that's smaller than the combined (unscaled) corner images.
@@ skipping 34 matching lines @@
   EXPECT_TRUE(grid.center_layer()->visible());
 
   // We shouldn't be clipping the corner images anymore.
   EXPECT_TRUE(test_api.top_left_clip_rect().IsEmpty());
   EXPECT_TRUE(test_api.top_right_clip_rect().IsEmpty());
   EXPECT_TRUE(test_api.bottom_left_clip_rect().IsEmpty());
   EXPECT_TRUE(test_api.bottom_right_clip_rect().IsEmpty());
 }
 
 }  // namespace wm