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

cc/tiles/picture_layer_tiling_unittest.cc

 // Copyright 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 "cc/tiles/picture_layer_tiling.h"
+
 #include <stddef.h>
 
 #include <limits>
 #include <set>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "cc/base/math_util.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "cc/test/fake_raster_source.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
-#include "cc/tiles/picture_layer_tiling.h"
 #include "cc/tiles/picture_layer_tiling_set.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
 static gfx::Rect ViewportInLayerSpace(
     const gfx::Transform& transform,
     const gfx::Size& device_viewport) {
 
   gfx::Transform inverse;
   if (!transform.GetInverse(&inverse))
     return gfx::Rect();
 
   return MathUtil::ProjectEnclosingClippedRect(inverse,
                                                gfx::Rect(device_viewport));
 }
 
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
 
-  static scoped_ptr<TestablePictureLayerTiling> Create(
+  static std::unique_ptr<TestablePictureLayerTiling> Create(
       WhichTree tree,
       float contents_scale,
       scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       const LayerTreeSettings& settings) {
-    return make_scoped_ptr(new TestablePictureLayerTiling(
+    return base::WrapUnique(new TestablePictureLayerTiling(
         tree, contents_scale, raster_source, client,
         settings.tiling_interest_area_padding,
         settings.skewport_target_time_in_seconds,
         settings.skewport_extrapolation_limit_in_content_pixels));
   }
 
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
 
   using PictureLayerTiling::ComputeSkewport;
   using PictureLayerTiling::RemoveTileAt;
@@ skipping 127 matching lines @@
                                         const gfx::Rect& dest_rect) {
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         gfx::Rect(tiling_->tiling_size()), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
  protected:
   FakePictureLayerTilingClient client_;
-  scoped_ptr<TestablePictureLayerTiling> tiling_;
+  std::unique_ptr<TestablePictureLayerTiling> tiling_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest);
 };
 
 TEST_F(PictureLayerTilingIteratorTest, ResizeDeletesTiles) {
   // Verifies that a resize with invalidation for newly exposed pixels will
   // deletes tiles that intersect that invalidation.
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(10, 10);
@@ skipping 365 matching lines @@
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
   settings.skewport_extrapolation_limit_in_content_pixels = 75;
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, settings);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
@@ skipping 63 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, ComputeSkewportExtremeCases) {
   FakePictureLayerTilingClient client;
 
   gfx::Size layer_bounds(200, 200);
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, settings);
 
   gfx::Rect viewport1(-1918, 255860, 4010, 2356);
   gfx::Rect viewport2(-7088, -91738, 14212, 8350);
   gfx::Rect viewport3(-12730024, -158883296, 24607540, 14454512);
   double time = 1.0;
   tiling->ComputeTilePriorityRects(viewport1, 1.f, time, Occlusion());
   time += 0.016;
   EXPECT_TRUE(tiling->ComputeSkewport(time, viewport2).Contains(viewport2));
@@ skipping 12 matching lines @@
 TEST(PictureLayerTilingTest, ComputeSkewport) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
@@ skipping 41 matching lines @@
 TEST(PictureLayerTilingTest, SkewportThroughUpdateTilePriorities) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect viewport_50 = gfx::Rect(0, 50, 100, 100);
   gfx::Rect skewport_50 = tiling->ComputeSkewport(1.5, viewport_50);
 
   EXPECT_EQ(gfx::Rect(0, 50, 100, 200), skewport_50);
@@ skipping 53 matching lines @@
   client.SetTileSize(gfx::Size(10, 10));
   LayerTreeSettings settings;
 
   // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
   // The reason is that each tile has a one pixel border, so tile at (1, 2)
   // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
   // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
   // tiling.
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.25f, raster_source,
                                          &client, settings);
   tiling->set_resolution(HIGH_RESOLUTION);
   gfx::Rect viewport_in_content_space =
       gfx::ScaleToEnclosedRect(viewport, 0.25f);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   // Compute the soon border.
@@ skipping 289 matching lines @@
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
@@ skipping 34 matching lines @@
   current_screen_transform.Translate(850, 0);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
@@ skipping 44 matching lines @@
   current_screen_transform.Translate(705, 505);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
@@ skipping 38 matching lines @@
   current_screen_transform.RotateAboutZAxis(45);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
@@ skipping 63 matching lines @@
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
@@ skipping 73 matching lines @@
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
@@ skipping 43 matching lines @@
   last_screen_transform.Translate(2800, 0);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
-  scoped_ptr<TestablePictureLayerTiling> tiling =
+  std::unique_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &client, settings);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   // previous ("last") frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    last_layer_contents_scale,
                                    last_frame_time_in_seconds, Occlusion());
 
   // current frame
@@ skipping 25 matching lines @@
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, RotationMotion) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that ComputeTilePriorityRects correctly accounts for the transform between
   // layer space and screen space.
 
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
+  std::unique_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscren.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double last_frame_time_in_seconds = 1.0;
@@ skipping 62 matching lines @@
   // - Recycle tiling does _not_ have the tile in the same location (thus it
   //   will be shared next time a pending tiling is created).
 
   FakePictureLayerTilingClient active_client;
 
   active_client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(gfx::Size(10000, 10000));
-  scoped_ptr<TestablePictureLayerTiling> active_tiling =
+  std::unique_ptr<TestablePictureLayerTiling> active_tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &active_client, settings);
   active_tiling->set_resolution(HIGH_RESOLUTION);
   // Create all tiles on this tiling.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
                                           Occlusion());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_twin_tiling(active_tiling.get());
 
   raster_source = FakeRasterSource::CreateFilled(gfx::Size(10000, 10000));
-  scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
+  std::unique_ptr<TestablePictureLayerTiling> recycle_tiling =
       TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
                                          &recycle_client, settings);
   recycle_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Create all tiles on the second tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 TEST(PictureLayerTilingTest, RecycledTilesClearedOnReset) {
   FakePictureLayerTilingClient active_client;
   active_client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(gfx::Size(100, 100));
-  scoped_ptr<TestablePictureLayerTiling> active_tiling =
+  std::unique_ptr<TestablePictureLayerTiling> active_tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
                                          &active_client, LayerTreeSettings());
   active_tiling->set_resolution(HIGH_RESOLUTION);
   // Create all tiles on this tiling.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
                                           Occlusion());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_twin_tiling(active_tiling.get());
 
   LayerTreeSettings settings;
 
   raster_source = FakeRasterSource::CreateFilled(gfx::Size(100, 100));
-  scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
+  std::unique_ptr<TestablePictureLayerTiling> recycle_tiling =
       TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
                                          &recycle_client, settings);
   recycle_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Create all tiles on the recycle tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   recycle_client.set_twin_tiling(NULL);
 
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 
   // Reset the active tiling. The recycle tiles should be released too.
   active_tiling->Reset();
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 TEST(PictureLayerTilingTest, InvalidateAfterComputeTilePriorityRects) {
   FakePictureLayerTilingClient pending_client;
   pending_client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(gfx::Size(100, 100));
-  scoped_ptr<TestablePictureLayerTiling> pending_tiling =
+  std::unique_ptr<TestablePictureLayerTiling> pending_tiling =
       TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
                                          &pending_client, LayerTreeSettings());
   pending_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Ensure that we can compute tile priority rects, invalidate, and compute the
   // rects again. It is important that the second compute tile priority rects
   // return true, indicating that things have changed (since invalidation has
   // changed things). This causes PrepareTiles to be properly scheduled. If the
   // second ComputeTilePriorityRects returns false, then we assume that
   // PrepareTiles isn't needed and we signal that we're ready to draw
@@ skipping 49 matching lines @@
   tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, contents_scale,
                                                raster_source, &client_,
                                                LayerTreeSettings());
 
   gfx::Rect content_rect(25554432, 25554432, 950, 860);
   VerifyTilesExactlyCoverRect(contents_scale, content_rect);
 }
 
 }  // namespace
 }  // namespace cc