Convert //cc from scoped_ptr to std::unique_ptr.

cc/playback/recording_source_unittest.cc

 // Copyright 2015 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 <vector>
 
+#include "base/memory/ptr_util.h"
 #include "cc/base/region.h"
 #include "cc/playback/raster_source.h"
 #include "cc/proto/recording_source.pb.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/skia_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
-scoped_ptr<FakeRecordingSource> CreateRecordingSource(
+std::unique_ptr<FakeRecordingSource> CreateRecordingSource(
     const gfx::Rect& viewport) {
   gfx::Rect layer_rect(viewport.right(), viewport.bottom());
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateRecordingSource(viewport, layer_rect.size());
   return recording_source;
 }
 
 scoped_refptr<RasterSource> CreateRasterSource(
     FakeRecordingSource* recording_source) {
   bool can_use_lcd_text = true;
   return RasterSource::CreateFromRecordingSource(recording_source,
                                                  can_use_lcd_text);
 }
 
 void ValidateRecordingSourceSerialization(FakeRecordingSource* source) {
-  scoped_ptr<FakeImageSerializationProcessor>
+  std::unique_ptr<FakeImageSerializationProcessor>
       fake_image_serialization_processor =
-          make_scoped_ptr(new FakeImageSerializationProcessor);
+          base::WrapUnique(new FakeImageSerializationProcessor);
 
   proto::RecordingSource proto;
   source->ToProtobuf(&proto, fake_image_serialization_processor.get());
 
   FakeRecordingSource new_source;
   new_source.FromProtobuf(proto, fake_image_serialization_processor.get());
 
   EXPECT_TRUE(source->EqualsTo(new_source));
 }
 
 TEST(RecordingSourceTest, TestNullDisplayListSerialization) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetDisplayListUsesCachedPicture(false);
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
   recording_source->SetEmptyBounds();
 
   ValidateRecordingSourceSerialization(recording_source.get());
 }
 
 TEST(RecordingSourceTest, TestEmptySerializationDeserialization) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetDisplayListUsesCachedPicture(false);
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   ValidateRecordingSourceSerialization(recording_source.get());
 }
 
 TEST(RecordingSourceTest, TestPopulatedSerializationDeserialization) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetDisplayListUsesCachedPicture(false);
 
   SkPaint simple_paint;
   simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
   recording_source->add_draw_rect_with_paint(gfx::Rect(0, 0, 256, 256),
                                              simple_paint);
   recording_source->add_draw_rect_with_paint(gfx::Rect(128, 128, 512, 512),
                                              simple_paint);
   recording_source->add_draw_rect_with_paint(gfx::Rect(512, 0, 256, 256),
                                              simple_paint);
   recording_source->add_draw_rect_with_paint(gfx::Rect(0, 512, 256, 256),
                                              simple_paint);
 
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   ValidateRecordingSourceSerialization(recording_source.get());
 }
 
 TEST(RecordingSourceTest, DiscardableImagesWithTransform) {
   gfx::Rect recorded_viewport(256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(
           recorded_viewport.size());
   skia::RefPtr<SkImage> discardable_image[2][2];
   gfx::Transform identity_transform;
   discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
   // Translate transform is equivalent to moving using point.
   gfx::Transform translate_transform;
   translate_transform.Translate(0, 130);
   discardable_image[1][0] = CreateDiscardableImage(gfx::Size(32, 32));
   // This moves the bitmap to center of viewport and rotate, this would make
@@ skipping 70 matching lines @@
                                               scale, &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_FLOAT_EQ(scale, images[0].scale().width());
     EXPECT_FLOAT_EQ(scale, images[0].scale().height());
   }
 }
 
 TEST(RecordingSourceTest, NoGatherImageEmptyImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetGenerateDiscardableImagesMetadata(false);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // If recording source do not gather images, raster source is not going to
   // get images.
   {
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(recorded_viewport, 1.f, &images);
     EXPECT_TRUE(images.empty());
   }
 }
 
 TEST(RecordingSourceTest, EmptyImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // Tile sized iterators.
   {
     std::vector<DrawImage> images;
@@ skipping 13 matching lines @@
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
                                               &images);
     EXPECT_TRUE(images.empty());
   }
 }
 
 TEST(RecordingSourceTest, NoDiscardableImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
 
   SkPaint simple_paint;
   simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
 
   SkBitmap non_discardable_bitmap;
   non_discardable_bitmap.allocN32Pixels(128, 128);
   non_discardable_bitmap.setImmutable();
   skia::RefPtr<SkImage> non_discardable_image =
       skia::AdoptRef(SkImage::NewFromBitmap(non_discardable_bitmap));
@@ skipping 37 matching lines @@
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
                                               &images);
     EXPECT_TRUE(images.empty());
   }
 }
 
 TEST(RecordingSourceTest, DiscardableImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
 
   skia::RefPtr<SkImage> discardable_image[2][2];
   discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
   discardable_image[1][0] = CreateDiscardableImage(gfx::Size(32, 32));
   discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32));
 
   // Discardable images are found in the following cells:
   // |---|---|
   // | x |   |
@@ skipping 46 matching lines @@
     EXPECT_EQ(3u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
     EXPECT_TRUE(images[1].image() == discardable_image[1][0].get());
     EXPECT_TRUE(images[2].image() == discardable_image[1][1].get());
   }
 }
 
 TEST(RecordingSourceTest, DiscardableImagesBaseNonDiscardable) {
   gfx::Rect recorded_viewport(0, 0, 512, 512);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
 
   SkBitmap non_discardable_bitmap;
   non_discardable_bitmap.allocN32Pixels(512, 512);
   non_discardable_bitmap.setImmutable();
   skia::RefPtr<SkImage> non_discardable_image =
       skia::AdoptRef(SkImage::NewFromBitmap(non_discardable_bitmap));
 
   skia::RefPtr<SkImage> discardable_image[2][2];
   discardable_image[0][0] = CreateDiscardableImage(gfx::Size(128, 128));
@@ skipping 51 matching lines @@
                                               &images);
     EXPECT_EQ(3u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0].get());
     EXPECT_TRUE(images[1].image() == discardable_image[0][1].get());
     EXPECT_TRUE(images[2].image() == discardable_image[1][1].get());
   }
 }
 
 }  // namespace
 }  // namespace cc