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

cc/playback/raster_source_unittest.cc

 // Copyright 2013 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 "cc/playback/raster_source.h"
+
 #include <stddef.h>
 
-#include "base/memory/scoped_ptr.h"
-#include "cc/playback/raster_source.h"
+#include <memory>
+
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/skia_common.h"
 #include "skia/ext/refptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
 TEST(RasterSourceTest, AnalyzeIsSolidUnscaled) {
   gfx::Size layer_bounds(400, 400);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
   SkPaint solid_paint;
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
   solid_paint.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
   SkColor color = SK_ColorTRANSPARENT;
   SkPaint non_solid_paint;
   bool is_solid_color = false;
@@ skipping 50 matching lines @@
   color = SK_ColorTRANSPARENT;
   is_solid_color = raster->PerformSolidColorAnalysis(
       gfx::Rect(350, 350, 100, 100), 1.0, &color);
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(solid_color, color);
 }
 
 TEST(RasterSourceTest, AnalyzeIsSolidScaled) {
   gfx::Size layer_bounds(400, 400);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
   SkColor color = SK_ColorTRANSPARENT;
   SkPaint solid_paint;
   bool is_solid_color = false;
   solid_paint.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
   SkPaint non_solid_paint;
@@ skipping 50 matching lines @@
   color = SK_ColorTRANSPARENT;
   is_solid_color = raster->PerformSolidColorAnalysis(gfx::Rect(35, 35, 10, 10),
                                                      0.1f, &color);
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(color, solid_color);
 }
 
 TEST(RasterSourceTest, AnalyzeIsSolidEmpty) {
   gfx::Size layer_bounds(400, 400);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   SkColor color = SK_ColorTRANSPARENT;
   bool is_solid_color =
       raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 400, 400), 1.f, &color);
 
   EXPECT_TRUE(is_solid_color);
   EXPECT_EQ(color, SkColorSetARGB(0, 0, 0, 0));
 }
 
 TEST(RasterSourceTest, PixelRefIteratorDiscardableRefsOneTile) {
   gfx::Size layer_bounds(512, 512);
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
   skia::RefPtr<SkImage> discardable_image[2][2];
   discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32));
   discardable_image[0][1] = CreateDiscardableImage(gfx::Size(32, 32));
   discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32));
 
   // Discardable pixel refs are found in the following cells:
   // |---|---|
   // | x | x |
@@ skipping 43 matching lines @@
     EXPECT_EQ(discardable_image[0][1].get(), images[1].image());
     EXPECT_EQ(discardable_image[1][1].get(), images[2].image());
   }
 }
 
 TEST(RasterSourceTest, RasterFullContents) {
   gfx::Size layer_bounds(3, 5);
   float contents_scale = 1.5f;
   float raster_divisions = 2.f;
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorBLACK);
   recording_source->SetClearCanvasWithDebugColor(false);
 
   // Because the caller sets content opaque, it also promises that it
   // has at least filled in layer_bounds opaquely.
   SkPaint white_paint;
   white_paint.setColor(SK_ColorWHITE);
   recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
                                              white_paint);
@@ skipping 45 matching lines @@
       // will be non-white.
       EXPECT_EQ(all_white, gfx::Rect(content_bounds).Contains(canvas_rect));
     }
   }
 }
 
 TEST(RasterSourceTest, RasterPartialContents) {
   gfx::Size layer_bounds(3, 5);
   float contents_scale = 1.5f;
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorGREEN);
   recording_source->SetClearCanvasWithDebugColor(false);
 
   // First record everything as white.
   SkPaint white_paint;
   white_paint.setColor(SK_ColorWHITE);
   recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
                                              white_paint);
   recording_source->Rerecord();
@@ skipping 71 matching lines @@
   }
   EXPECT_GT(num_black, 0);
   EXPECT_GT(num_white, 0);
 }
 
 TEST(RasterSourceTest, RasterPartialClear) {
   gfx::Size layer_bounds(3, 5);
   gfx::Size partial_bounds(2, 4);
   float contents_scale = 1.5f;
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorGREEN);
   recording_source->SetRequiresClear(true);
   recording_source->SetClearCanvasWithDebugColor(false);
 
   // First record everything as white.
   const unsigned alpha_dark = 10u;
   SkPaint white_paint;
   white_paint.setColor(SK_ColorWHITE);
   white_paint.setAlpha(alpha_dark);
@@ skipping 25 matching lines @@
         SCOPED_TRACE(i);
         SCOPED_TRACE(j);
         EXPECT_EQ(alpha_dark, SkColorGetA(pixels[i + j * bitmap.width()]));
         EXPECT_EQ(alpha_dark, SkColorGetR(pixels[i + j * bitmap.width()]));
         EXPECT_EQ(alpha_dark, SkColorGetG(pixels[i + j * bitmap.width()]));
         EXPECT_EQ(alpha_dark, SkColorGetB(pixels[i + j * bitmap.width()]));
       }
     }
   }
 
-  scoped_ptr<FakeRecordingSource> recording_source_light =
+  std::unique_ptr<FakeRecordingSource> recording_source_light =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source_light->SetBackgroundColor(SK_ColorGREEN);
   recording_source_light->SetRequiresClear(true);
   recording_source_light->SetClearCanvasWithDebugColor(false);
 
   // Record everything as a slightly lighter white.
   const unsigned alpha_light = 18u;
   white_paint.setAlpha(alpha_light);
   recording_source_light->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
                                                    white_paint);
@@ skipping 22 matching lines @@
       EXPECT_EQ(alpha_light, SkColorGetG(pixels[i + j * bitmap.width()]));
       EXPECT_EQ(alpha_light, SkColorGetB(pixels[i + j * bitmap.width()]));
     }
   }
 }
 
 TEST(RasterSourceTest, RasterContentsTransparent) {
   gfx::Size layer_bounds(5, 3);
   float contents_scale = 0.5f;
 
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->SetBackgroundColor(SK_ColorTRANSPARENT);
   recording_source->SetRequiresClear(true);
   recording_source->SetClearCanvasWithDebugColor(false);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
   gfx::Size content_bounds(
       gfx::ScaleToCeiledSize(layer_bounds, contents_scale));
@@ skipping 11 matching lines @@
   SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
   int num_pixels = bitmap.width() * bitmap.height();
   for (int i = 0; i < num_pixels; ++i) {
     EXPECT_EQ(SkColorGetA(pixels[i]), 0u);
   }
 }
 
 TEST(RasterSourceTest, GetPictureMemoryUsageIncludesClientReportedMemory) {
   const size_t kReportedMemoryUsageInBytes = 100 * 1024 * 1024;
   gfx::Size layer_bounds(5, 3);
-  scoped_ptr<FakeRecordingSource> recording_source =
+  std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->set_reported_memory_usage(kReportedMemoryUsageInBytes);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
   size_t total_memory_usage = raster->GetPictureMemoryUsage();
   EXPECT_GE(total_memory_usage, kReportedMemoryUsageInBytes);
   EXPECT_LT(total_memory_usage, 2 * kReportedMemoryUsageInBytes);
 }
 
 }  // namespace
 }  // namespace cc