cc: Move gpu rasterization flag from tree-impl to tree-host-impl.

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 1709 matching lines @@
   // ReleaseResources has set needs update draw properties so that the
   // new tiling gets the appropriate resolution set in ManageTilings.
   EXPECT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
   host_impl_.active_tree()->UpdateDrawProperties();
   PictureLayerTiling* high_res =
       active_layer_->tilings()->TilingAtScale(new_scale);
   ASSERT_TRUE(!!high_res);
   EXPECT_EQ(HIGH_RESOLUTION, high_res->resolution());
 }
 
+TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
+  SetupDefaultTrees(gfx::Size(10, 10));
+
+  const float kScale = 1.f;
+  pending_layer_->AddTiling(kScale);
+  EXPECT_TRUE(pending_layer_->tilings()->TilingAtScale(kScale));
+  EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(kScale));
+
+  // Gpu rasterization is disabled by default.
+  EXPECT_FALSE(host_impl_.use_gpu_rasterization());
+  // Toggling the gpu rasterization clears all tilings on both trees.
+  host_impl_.SetUseGpuRasterization(true);
+  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
+
+  // Make sure that we can still add tiling to the pending layer,
+  // that gets synced to the active layer.
+  pending_layer_->AddTiling(kScale);
+  EXPECT_TRUE(pending_layer_->tilings()->TilingAtScale(kScale));
+  EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(kScale));
+
+  // Toggling the gpu rasterization clears all tilings on both trees.
+  EXPECT_TRUE(host_impl_.use_gpu_rasterization());
+  host_impl_.SetUseGpuRasterization(false);
+  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
+}
+
 TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   SetupDefaultTrees(gfx::Size(10, 10));
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
   float result_scale_x;
   float result_scale_y;
   gfx::Size result_bounds;
   active_layer_->CalculateContentsScale(0.5f,
                                         0.5f,
@@ skipping 42 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupDefaultTrees(layer_bounds);
-  EXPECT_FALSE(pending_layer_->use_gpu_rasterization());
+  EXPECT_FALSE(host_impl_.use_gpu_rasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
                                          1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   // Should have a low-res and a high-res tiling.
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   ResetTilingsAndRasterScales();
 
-  host_impl_.pending_tree()->SetUseGpuRasterization(true);
-  EXPECT_TRUE(pending_layer_->use_gpu_rasterization());
+  host_impl_.SetUseGpuRasterization(true);
+  EXPECT_TRUE(host_impl_.use_gpu_rasterization());
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
                                          1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   // Should only have the high-res tiling.
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
@@ skipping 537 matching lines @@
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
 }
 
 }  // namespace
 }  // namespace cc