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

cc/layers/picture_layer_impl_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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 53 matching lines @@
         active_layer_(nullptr) {}
 
   explicit PictureLayerImplTest(const LayerTreeSettings& settings)
       : proxy_(base::MessageLoopProxy::current()),
         host_impl_(settings, &proxy_, &shared_bitmap_manager_),
         id_(7) {}
 
   virtual ~PictureLayerImplTest() {
   }
 
-  virtual void SetUp() override {
-    InitializeRenderer();
-  }
+  void SetUp() override { InitializeRenderer(); }
 
   virtual void InitializeRenderer() {
     host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
     gfx::Size tile_size(100, 100);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 789 matching lines @@
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(2.0f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(1.0f,
                   active_layer_->tilings()->tiling_at(1)->contents_scale());
   EXPECT_FLOAT_EQ(2.0f * low_res_factor,
                   active_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // Zoom out further, close to our low-res scale factor. We should
   // use that tiling as high-res, and not create a new tiling.
-  SetContentsScaleOnBothLayers(
-      low_res_factor, 1.0f, low_res_factor / 2.0f, 1.0f, false);
+  SetContentsScaleOnBothLayers(low_res_factor * 2.1f, 1.0f,
+                               low_res_factor * 2.1f, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // Zoom in a lot now. Since we increase by increments of
-  // kMaxScaleRatioDuringPinch, this will first use 1.0, then 2.0
-  // and then finally create a new tiling at 4.0.
-  SetContentsScaleOnBothLayers(4.2f, 1.0f, 2.1f, 1.f, false);
-  EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(4.2f, 1.0f, 2.1f, 1.f, false);
-  EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(4.2f, 1.0f, 2.1f, 1.f, false);
+  // kMaxScaleRatioDuringPinch, this will create a new tiling at 4.0.
+  SetContentsScaleOnBothLayers(3.8f, 1.0f, 2.1f, 1.f, false);
   EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(4.0f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
   gfx::Size tile_size(300, 300);
   gfx::Size layer_bounds(2600, 3800);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
@@ skipping 23 matching lines @@
   EXPECT_FLOAT_EQ(0.12f,
                   active_layer_->tilings()->tiling_at(1)->contents_scale());
   EXPECT_FLOAT_EQ(0.0625,
                   active_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // Zoom out further, close to our low-res scale factor. We should
   // use that tiling as high-res, and not create a new tiling.
   SetContentsScaleOnBothLayers(0.1f, 1.0f, 0.1f, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 
-  // Zoom in. 0.125(desired_scale) should be snapped to 0.12 during zoom-in
-  // because 0.125(desired_scale) is within the ratio(1.2)
-  SetContentsScaleOnBothLayers(0.5f, 1.0f, 0.5f, 1.0f, false);
+  // Zoom in. 0.25(desired_scale) should be snapped to 0.24 during zoom-in
+  // because 0.25(desired_scale) is within the ratio(1.2).
+  SetContentsScaleOnBothLayers(0.25f, 1.0f, 0.25f, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
+
+  // Zoom in a lot. Since we move in factors of two, we should get a scale that
+  // is a power of 2 times 0.24.
+  SetContentsScaleOnBothLayers(1.f, 1.0f, 1.f, 1.0f, false);
+  EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.92f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 226 matching lines @@
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(),
                  contents_scale * low_res_factor);
   EXPECT_BOTH_EQ(num_tilings(), 2u);
 
   ResetTilingsAndRasterScales();
 
   // Mask layers dont create low res since they always fit on one tile.
-  pending_pile->SetIsMask(true);
-  active_pile->SetIsMask(true);
+  pending_layer_->set_is_mask(true);
+  active_layer_->set_is_mask(true);
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 }
 
 TEST_F(PictureLayerImplTest, HugeMasksDontGetTiles) {
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
-  valid_pile->SetIsMask(true);
   SetupPendingTree(valid_pile);
+  pending_layer_->set_is_mask(true);
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_layer_->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   // Mask layers have a tiling with a single tile in it.
   EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
   ResourceProvider::ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
   active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_NE(0u, mask_resource_id);
   EXPECT_EQ(mask_texture_size, active_layer_->bounds());
 
   // Resize larger than the max texture size.
   int max_texture_size = host_impl_.GetRendererCapabilities().max_texture_size;
   scoped_refptr<FakePicturePileImpl> huge_pile =
       FakePicturePileImpl::CreateFilledPile(
           tile_size, gfx::Size(max_texture_size + 1, 10));
-  huge_pile->SetIsMask(true);
   SetupPendingTree(huge_pile);
+  pending_layer_->set_is_mask(true);
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_layer_->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   // Mask layers have a tiling, but there should be no tiles in it.
   EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
   // The mask resource is empty.
   active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_EQ(0u, mask_resource_id);
 }
 
 TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
-  valid_pile->SetIsMask(true);
   SetupPendingTree(valid_pile);
+  pending_layer_->set_is_mask(true);
 
   float ideal_contents_scale = 1.3f;
   SetupDrawPropertiesAndUpdateTiles(
       pending_layer_, ideal_contents_scale, 1.f, 1.f, 1.f, false);
   EXPECT_EQ(ideal_contents_scale,
             pending_layer_->HighResTiling()->contents_scale());
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
@@ skipping 749 matching lines @@
   gfx::Size tile_size(100, 100);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   gfx::Size pending_layer_bounds(400, 400);
   pending_layer_->SetBounds(pending_layer_bounds);
 
   CreateHighLowResAndSetAllTilesVisible();
   // TODO(vmpstr): This is confusing. Rework the test to create different bounds
   // on different trees instead of fudging tilings.
   pending_layer_->HighResTiling()->ComputeTilePriorityRects(
-      PENDING_TREE, gfx::Rect(pending_layer_bounds), 1.f, 1.f, Occlusion());
+      gfx::Rect(pending_layer_bounds), 1.f, 1.f, Occlusion());
 
   pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   active_layer_->SetAllTilesReady();
 
   // Since the active layer has different bounds, the pending layer needs all
   // high res tiles in order to activate.
   pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
   AssertAllTilesRequired(pending_layer_->HighResTiling());
@@ skipping 69 matching lines @@
   EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
   EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
   EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
   EXPECT_TRUE(pending_tiling->TileAt(0, 0)->is_shared());
   EXPECT_TRUE(pending_tiling->TileAt(1, 0)->is_shared());
   EXPECT_TRUE(pending_tiling->TileAt(0, 1)->is_shared());
   EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());
 
   // Drop the tiles on the active tree and recreate them. The same tiles
   // should be shared or not.
-  active_tiling->ComputeTilePriorityRects(
-      ACTIVE_TREE, gfx::Rect(), 1.f, 1.0, Occlusion());
+  active_tiling->ComputeTilePriorityRects(gfx::Rect(), 1.f, 1.0, Occlusion());
   EXPECT_TRUE(active_tiling->AllTilesForTesting().empty());
   active_tiling->CreateAllTilesForTesting();
 
   // Tile 0,0 should be shared, but tile 1,1 should not be.
   EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
   EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
   EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
   EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
   EXPECT_TRUE(pending_tiling->TileAt(0, 0)->is_shared());
   EXPECT_TRUE(pending_tiling->TileAt(1, 0)->is_shared());
@@ skipping 320 matching lines @@
   ASSERT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(contents_scale,
                   pending_layer_->HighResTiling()->contents_scale());
 
   host_impl_.PinchGestureBegin();
 
   float page_scale = 0.0001f;
   EXPECT_LT(page_scale * contents_scale,
             pending_layer_->MinimumContentsScale());
 
-  SetContentsScaleOnBothLayers(contents_scale, 1.f, page_scale, 1.f, false);
+  SetContentsScaleOnBothLayers(contents_scale * page_scale, 1.f, page_scale,
+                               1.f, false);
   ASSERT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
                   pending_layer_->HighResTiling()->contents_scale());
 }
 
 class DeferredInitPictureLayerImplTest : public PictureLayerImplTest {
  public:
   void InitializeRenderer() override {
     bool delegated_rendering = false;
     host_impl_.InitializeRenderer(FakeOutputSurface::CreateDeferredGL(
         scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
         delegated_rendering));
   }
 
-  virtual void SetUp() override {
+  void SetUp() override {
     PictureLayerImplTest::SetUp();
 
     // Create some default active and pending trees.
     gfx::Size tile_size(100, 100);
     gfx::Size layer_bounds(400, 400);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 1221 matching lines @@
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.pending_tree(), 1);
 
   scoped_ptr<FakePictureLayerImpl> layer_with_mask =
       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 2);
 
   layer_with_mask->SetBounds(bounds);
   layer_with_mask->SetContentBounds(bounds);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, bounds);
-  pending_pile->SetIsMask(true);
   scoped_ptr<FakePictureLayerImpl> mask =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 3,
                                                    pending_pile);
+  mask->set_is_mask(true);
 
   mask->SetBounds(bounds);
   mask->SetContentBounds(bounds);
   mask->SetDrawsContent(true);
 
   FakePictureLayerImpl* pending_mask_content = mask.get();
   layer_with_mask->SetMaskLayer(mask.Pass());
 
   scoped_ptr<FakePictureLayerImpl> child_of_layer_with_mask =
       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 4);
@@ skipping 764 matching lines @@
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   host_impl_.SetViewportSize(layer_bounds);
 
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(!test_for_solid);
 
   Region invalidation(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
-      &client, &invalidation, SK_ColorWHITE, false, false, layer_bounds,
-      layer_rect, frame_number++, Picture::RECORD_NORMALLY);
+      &client, &invalidation, layer_bounds, layer_rect, frame_number++,
+      Picture::RECORD_NORMALLY);
 
   scoped_refptr<RasterSource> pending_raster_source =
       recording_source->CreateRasterSource();
 
   SetupPendingTree(pending_raster_source);
   ActivateTree();
 
   active_layer_->set_fixed_tile_size(tile_size);
   host_impl_.active_tree()->UpdateDrawProperties();
   if (test_for_solid) {
@@ skipping 45 matching lines @@
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   host_impl_.SetViewportSize(layer_bounds);
 
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(true);
 
   Region invalidation1(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
-      &client, &invalidation1, SK_ColorWHITE, false, false, layer_bounds,
-      layer_rect, frame_number++, Picture::RECORD_NORMALLY);
+      &client, &invalidation1, layer_bounds, layer_rect, frame_number++,
+      Picture::RECORD_NORMALLY);
 
   scoped_refptr<RasterSource> raster_source1 =
       recording_source->CreateRasterSource();
 
   SetupPendingTree(raster_source1);
   ActivateTree();
   host_impl_.active_tree()->UpdateDrawProperties();
 
   // We've started with a solid layer that contains some tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_NE(0u, active_layer_->tilings()->num_tilings());
 
   client.set_fill_with_nonsolid_color(false);
 
   Region invalidation2(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
-      &client, &invalidation2, SK_ColorWHITE, false, false, layer_bounds,
-      layer_rect, frame_number++, Picture::RECORD_NORMALLY);
+      &client, &invalidation2, layer_bounds, layer_rect, frame_number++,
+      Picture::RECORD_NORMALLY);
 
   scoped_refptr<RasterSource> raster_source2 =
       recording_source->CreateRasterSource();
 
   SetupPendingTree(raster_source2);
   ActivateTree();
 
   // We've switched to a solid color, so we should end up with no tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
@@ skipping 118 matching lines @@
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 }  // namespace
 }  // namespace cc