Update from chromium https://crrev.com/304586

cc/resources/picture_layer_tiling_set_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/resources/picture_layer_tiling_set.h"
 
 #include <map>
 #include <vector>
 
 #include "cc/resources/resource_provider.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/test_shared_bitmap_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
 TEST(PictureLayerTilingSetTest, NoResources) {
   FakePictureLayerTilingClient client;
   gfx::Size layer_bounds(1000, 800);
-  PictureLayerTilingSet set(&client);
+  auto set = PictureLayerTilingSet::Create(&client);
   client.SetTileSize(gfx::Size(256, 256));
 
-  set.AddTiling(1.0, layer_bounds);
-  set.AddTiling(1.5, layer_bounds);
-  set.AddTiling(2.0, layer_bounds);
+  set->AddTiling(1.0, layer_bounds);
+  set->AddTiling(1.5, layer_bounds);
+  set->AddTiling(2.0, layer_bounds);
 
   float contents_scale = 2.0;
   gfx::Size content_bounds(
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale)));
   gfx::Rect content_rect(content_bounds);
 
   Region remaining(content_rect);
-  PictureLayerTilingSet::CoverageIterator iter(
-      &set,
-      contents_scale,
-      content_rect,
-      contents_scale);
+  PictureLayerTilingSet::CoverageIterator iter(set.get(), contents_scale,
+                                               content_rect, contents_scale);
   for (; iter; ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     EXPECT_TRUE(content_rect.Contains(geometry_rect));
     ASSERT_TRUE(remaining.Contains(geometry_rect));
     remaining.Subtract(geometry_rect);
 
     // No tiles have resources, so no iter represents a real tile.
     EXPECT_FALSE(*iter);
   }
   EXPECT_TRUE(remaining.IsEmpty());
 }
 
 TEST(PictureLayerTilingSetTest, TilingRange) {
   FakePictureLayerTilingClient client;
   gfx::Size layer_bounds(10, 10);
   PictureLayerTilingSet::TilingRange higher_than_high_res_range(0, 0);
   PictureLayerTilingSet::TilingRange high_res_range(0, 0);
   PictureLayerTilingSet::TilingRange between_high_and_low_res_range(0, 0);
   PictureLayerTilingSet::TilingRange low_res_range(0, 0);
   PictureLayerTilingSet::TilingRange lower_than_low_res_range(0, 0);
   PictureLayerTiling* high_res_tiling;
   PictureLayerTiling* low_res_tiling;
 
-  PictureLayerTilingSet set(&client);
-  set.AddTiling(2.0, layer_bounds);
-  high_res_tiling = set.AddTiling(1.0, layer_bounds);
+  auto set = PictureLayerTilingSet::Create(&client);
+  set->AddTiling(2.0, layer_bounds);
+  high_res_tiling = set->AddTiling(1.0, layer_bounds);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  set.AddTiling(0.5, layer_bounds);
-  low_res_tiling = set.AddTiling(0.25, layer_bounds);
+  set->AddTiling(0.5, layer_bounds);
+  low_res_tiling = set->AddTiling(0.25, layer_bounds);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
-  set.AddTiling(0.125, layer_bounds);
+  set->AddTiling(0.125, layer_bounds);
 
   higher_than_high_res_range =
-      set.GetTilingRange(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
+      set->GetTilingRange(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u, higher_than_high_res_range.start);
   EXPECT_EQ(1u, higher_than_high_res_range.end);
 
-  high_res_range = set.GetTilingRange(PictureLayerTilingSet::HIGH_RES);
+  high_res_range = set->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(1u, high_res_range.start);
   EXPECT_EQ(2u, high_res_range.end);
 
   between_high_and_low_res_range =
-      set.GetTilingRange(PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
+      set->GetTilingRange(PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(2u, between_high_and_low_res_range.start);
   EXPECT_EQ(3u, between_high_and_low_res_range.end);
 
-  low_res_range = set.GetTilingRange(PictureLayerTilingSet::LOW_RES);
+  low_res_range = set->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(3u, low_res_range.start);
   EXPECT_EQ(4u, low_res_range.end);
 
   lower_than_low_res_range =
-      set.GetTilingRange(PictureLayerTilingSet::LOWER_THAN_LOW_RES);
+      set->GetTilingRange(PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(4u, lower_than_low_res_range.start);
   EXPECT_EQ(5u, lower_than_low_res_range.end);
 
-  PictureLayerTilingSet set_without_low_res(&client);
-  set_without_low_res.AddTiling(2.0, layer_bounds);
-  high_res_tiling = set_without_low_res.AddTiling(1.0, layer_bounds);
+  auto set_without_low_res = PictureLayerTilingSet::Create(&client);
+  set_without_low_res->AddTiling(2.0, layer_bounds);
+  high_res_tiling = set_without_low_res->AddTiling(1.0, layer_bounds);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  set_without_low_res.AddTiling(0.5, layer_bounds);
-  set_without_low_res.AddTiling(0.25, layer_bounds);
+  set_without_low_res->AddTiling(0.5, layer_bounds);
+  set_without_low_res->AddTiling(0.25, layer_bounds);
 
-  higher_than_high_res_range = set_without_low_res.GetTilingRange(
+  higher_than_high_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u, higher_than_high_res_range.start);
   EXPECT_EQ(1u, higher_than_high_res_range.end);
 
   high_res_range =
-      set_without_low_res.GetTilingRange(PictureLayerTilingSet::HIGH_RES);
+      set_without_low_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(1u, high_res_range.start);
   EXPECT_EQ(2u, high_res_range.end);
 
-  between_high_and_low_res_range = set_without_low_res.GetTilingRange(
+  between_high_and_low_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(2u, between_high_and_low_res_range.start);
   EXPECT_EQ(4u, between_high_and_low_res_range.end);
 
   low_res_range =
-      set_without_low_res.GetTilingRange(PictureLayerTilingSet::LOW_RES);
+      set_without_low_res->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(0u, low_res_range.end - low_res_range.start);
 
-  lower_than_low_res_range = set_without_low_res.GetTilingRange(
+  lower_than_low_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 
-  PictureLayerTilingSet set_with_only_high_and_low_res(&client);
-  high_res_tiling = set_with_only_high_and_low_res.AddTiling(1.0, layer_bounds);
+  auto set_with_only_high_and_low_res = PictureLayerTilingSet::Create(&client);
+  high_res_tiling =
+      set_with_only_high_and_low_res->AddTiling(1.0, layer_bounds);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  low_res_tiling = set_with_only_high_and_low_res.AddTiling(0.5, layer_bounds);
+  low_res_tiling = set_with_only_high_and_low_res->AddTiling(0.5, layer_bounds);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
 
-  higher_than_high_res_range = set_with_only_high_and_low_res.GetTilingRange(
+  higher_than_high_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u,
             higher_than_high_res_range.end - higher_than_high_res_range.start);
 
-  high_res_range = set_with_only_high_and_low_res.GetTilingRange(
+  high_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(0u, high_res_range.start);
   EXPECT_EQ(1u, high_res_range.end);
 
   between_high_and_low_res_range =
-      set_with_only_high_and_low_res.GetTilingRange(
+      set_with_only_high_and_low_res->GetTilingRange(
           PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
-  EXPECT_EQ(0u,
-            between_high_and_low_res_range.end -
-                between_high_and_low_res_range.start);
+  EXPECT_EQ(0u, between_high_and_low_res_range.end -
+                    between_high_and_low_res_range.start);
 
-  low_res_range = set_with_only_high_and_low_res.GetTilingRange(
+  low_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(1u, low_res_range.start);
   EXPECT_EQ(2u, low_res_range.end);
 
-  lower_than_low_res_range = set_with_only_high_and_low_res.GetTilingRange(
+  lower_than_low_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 
-  PictureLayerTilingSet set_with_only_high_res(&client);
-  high_res_tiling = set_with_only_high_res.AddTiling(1.0, layer_bounds);
+  auto set_with_only_high_res = PictureLayerTilingSet::Create(&client);
+  high_res_tiling = set_with_only_high_res->AddTiling(1.0, layer_bounds);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
 
-  higher_than_high_res_range = set_with_only_high_res.GetTilingRange(
+  higher_than_high_res_range = set_with_only_high_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u,
             higher_than_high_res_range.end - higher_than_high_res_range.start);
 
   high_res_range =
-      set_with_only_high_res.GetTilingRange(PictureLayerTilingSet::HIGH_RES);
+      set_with_only_high_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(0u, high_res_range.start);
   EXPECT_EQ(1u, high_res_range.end);
 
-  between_high_and_low_res_range = set_with_only_high_res.GetTilingRange(
+  between_high_and_low_res_range = set_with_only_high_res->GetTilingRange(
       PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
-  EXPECT_EQ(0u,
-            between_high_and_low_res_range.end -
-                between_high_and_low_res_range.start);
+  EXPECT_EQ(0u, between_high_and_low_res_range.end -
+                    between_high_and_low_res_range.start);
 
   low_res_range =
-      set_with_only_high_res.GetTilingRange(PictureLayerTilingSet::LOW_RES);
+      set_with_only_high_res->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(0u, low_res_range.end - low_res_range.start);
 
-  lower_than_low_res_range = set_with_only_high_res.GetTilingRange(
+  lower_than_low_res_range = set_with_only_high_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 }
 
 class PictureLayerTilingSetTestWithResources : public testing::Test {
  public:
   void runTest(
       int num_tilings,
       float min_scale,
       float scale_increment,
@@ skipping 12 matching lines @@
                                  NULL,
                                  NULL,
                                  0,
                                  false,
                                  1);
 
     FakePictureLayerTilingClient client(resource_provider.get());
     client.SetTileSize(gfx::Size(256, 256));
     client.set_tree(PENDING_TREE);
     gfx::Size layer_bounds(1000, 800);
-    PictureLayerTilingSet set(&client);
+    auto set = PictureLayerTilingSet::Create(&client);
 
     float scale = min_scale;
     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
-      PictureLayerTiling* tiling = set.AddTiling(scale, layer_bounds);
+      PictureLayerTiling* tiling = set->AddTiling(scale, layer_bounds);
       tiling->CreateAllTilesForTesting();
       std::vector<Tile*> tiles = tiling->AllTilesForTesting();
       client.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
     }
 
     float max_contents_scale = scale;
     gfx::Size content_bounds(
         gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, max_contents_scale)));
     gfx::Rect content_rect(content_bounds);
 
     Region remaining(content_rect);
     PictureLayerTilingSet::CoverageIterator iter(
-        &set,
-        max_contents_scale,
-        content_rect,
-        ideal_contents_scale);
+        set.get(), max_contents_scale, content_rect, ideal_contents_scale);
     for (; iter; ++iter) {
       gfx::Rect geometry_rect = iter.geometry_rect();
       EXPECT_TRUE(content_rect.Contains(geometry_rect));
       ASSERT_TRUE(remaining.Contains(geometry_rect));
       remaining.Subtract(geometry_rect);
 
       float scale = iter.CurrentTiling()->contents_scale();
       EXPECT_EQ(expected_scale, scale);
 
       if (num_tilings)
@@ skipping 41 matching lines @@
 class PictureLayerTilingSetSyncTest : public testing::Test {
  public:
   PictureLayerTilingSetSyncTest()
       : tile_size_(gfx::Size(10, 10)),
         source_bounds_(gfx::Size(30, 20)),
         target_bounds_(gfx::Size(30, 30)) {
     source_client_.SetTileSize(tile_size_);
     source_client_.set_tree(PENDING_TREE);
     target_client_.SetTileSize(tile_size_);
     target_client_.set_tree(PENDING_TREE);
-    source_.reset(new PictureLayerTilingSet(&source_client_));
-    target_.reset(new PictureLayerTilingSet(&target_client_));
+    source_ = PictureLayerTilingSet::Create(&source_client_);
+    target_ = PictureLayerTilingSet::Create(&target_client_);
   }
 
   // Sync from source to target.
   void SyncTilings(const gfx::Size& new_bounds,
                    const Region& invalidation,
                    float minimum_scale) {
     for (size_t i = 0; i < source_->num_tilings(); ++i)
       source_->tiling_at(i)->CreateAllTilesForTesting();
     for (size_t i = 0; i < target_->num_tilings(); ++i)
       target_->tiling_at(i)->CreateAllTilesForTesting();
 
-    target_->SyncTilings(
-        *source_.get(), new_bounds, invalidation, minimum_scale);
+    target_->SyncTilings(*source_.get(), new_bounds, invalidation,
+                         minimum_scale, target_client_.raster_source());
   }
   void SyncTilings(const gfx::Size& new_bounds) {
     Region invalidation;
     SyncTilings(new_bounds, invalidation, 0.f);
   }
   void SyncTilings(const gfx::Size& new_bounds, const Region& invalidation) {
     SyncTilings(new_bounds, invalidation, 0.f);
   }
   void SyncTilings(const gfx::Size& new_bounds, float minimum_scale) {
     Region invalidation;
@@ skipping 24 matching lines @@
     if (target_->num_tilings() > 0) {
       float last_scale = target_->tiling_at(0)->contents_scale();
       for (size_t i = 1; i < target_->num_tilings(); ++i) {
         const PictureLayerTiling* target_tiling = target_->tiling_at(i);
         EXPECT_LT(target_tiling->contents_scale(), last_scale);
         last_scale = target_tiling->contents_scale();
       }
     }
 
     for (size_t i = 0; i < target_->num_tilings(); ++i)
-      ValidateTiling(target_->tiling_at(i), target_client_.GetRasterSource());
+      ValidateTiling(target_->tiling_at(i), target_client_.raster_source());
   }
 
   void ValidateTiling(const PictureLayerTiling* tiling,
                       const RasterSource* raster_source) {
     if (tiling->tiling_size().IsEmpty()) {
       EXPECT_TRUE(tiling->live_tiles_rect().IsEmpty());
     } else if (!tiling->live_tiles_rect().IsEmpty()) {
       gfx::Rect tiling_rect(tiling->tiling_size());
       EXPECT_TRUE(tiling_rect.Contains(tiling->live_tiles_rect()));
     }
@@ skipping 185 matching lines @@
   std::vector<Tile*> new_tiles = target_->tiling_at(0)->AllTilesForTesting();
   for (size_t i = 0; i < original_tiles.size(); ++i) {
     std::vector<Tile*>::iterator find =
         std::find(new_tiles.begin(), new_tiles.end(), original_tiles[i]);
     EXPECT_TRUE(find == new_tiles.end());
   }
 }
 
 }  // namespace
 }  // namespace cc