cc: Move gpu rasterization flag from LayerImpl to LayerTreeImpl.

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 1654 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_->ShouldUseGpuRasterization());
+  EXPECT_FALSE(pending_layer_->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());
 
-  pending_layer_->SetUseGpuRasterization(true);
-  EXPECT_TRUE(pending_layer_->ShouldUseGpuRasterization());
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+  ResetTilingsAndRasterScales();
+
+  host_impl_.pending_tree()->SetUseGpuRasterization(true);
+  EXPECT_TRUE(pending_layer_->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 195 matching lines @@
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
 }
 
 TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForGpuRasterization) {
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(tile_size);
-  pending_layer_->SetUseGpuRasterization(true);
-  active_layer_->SetUseGpuRasterization(true);
+  host_impl_.pending_tree()->SetUseGpuRasterization(true);
+  host_impl_.active_tree()->SetUseGpuRasterization(true);
+  EXPECT_TRUE(pending_layer_->use_gpu_rasterization());
+  EXPECT_TRUE(active_layer_->use_gpu_rasterization());
 
   float contents_scale = 1.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   bool animating_transform = false;
 
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
@@ skipping 374 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