cc: Move gpu rasterization flag from LayerImpl to LayerTreeImpl.

BUG=367198

Review URL: https://codereview.chromium.org/270823003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@269576 0039d316-1c4b-4281-b951-d872f2087c98

cc/layers/picture_layer.cc

@@ -53,7 +53,6 @@ void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
   }
 
   layer_impl->SetIsMask(is_mask_);
-  layer_impl->SetUseGpuRasterization(layer_tree_host()->UseGpuRasterization());
 
   // Unlike other properties, invalidation must always be set on layer_impl.
   // See PictureLayerImpl::PushPropertiesTo for more details.

cc/layers/picture_layer_impl.cc

@@ -21,7 +21,6 @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/tile_manager.h"
-#include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
@@ -63,7 +62,6 @@ PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false),
       should_use_low_res_tiling_(tree_impl->settings().create_low_res_tiling),
-      use_gpu_rasterization_(false),
       layer_needs_to_register_itself_(true) {
 }
 
@@ -105,7 +103,6 @@ void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
 
   layer_impl->SetIsMask(is_mask_);
   layer_impl->pile_ = pile_;
-  layer_impl->use_gpu_rasterization_ = use_gpu_rasterization_;
 
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
@@ -523,14 +520,6 @@ skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return pile_->GetFlattenedPicture();
 }
 
-void PictureLayerImpl::SetUseGpuRasterization(bool use_gpu) {
-  if (use_gpu_rasterization_ == use_gpu)
-    return;
-
-  use_gpu_rasterization_ = use_gpu;
-  RemoveAllTilings();
-}
-
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
                                                const gfx::Rect& content_rect) {
   if (!pile_->CanRaster(tiling->contents_scale(), content_rect))
@@ -539,7 +528,7 @@ scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
   int flags = 0;
   if (is_using_lcd_text_)
     flags |= Tile::USE_LCD_TEXT;
-  if (ShouldUseGpuRasterization())
+  if (use_gpu_rasterization())
     flags |= Tile::USE_GPU_RASTERIZATION;
   return layer_tree_impl()->tile_manager()->CreateTile(
       pile_.get(),
@@ -562,9 +551,8 @@ const Region* PictureLayerImpl::GetInvalidation() {
 
 const PictureLayerTiling* PictureLayerImpl::GetTwinTiling(
     const PictureLayerTiling* tiling) const {
-
   if (!twin_layer_ ||
-      twin_layer_->ShouldUseGpuRasterization() != ShouldUseGpuRasterization())
+      twin_layer_->use_gpu_rasterization() != use_gpu_rasterization())
     return NULL;
   for (size_t i = 0; i < twin_layer_->tilings_->num_tilings(); ++i)
     if (twin_layer_->tilings_->tiling_at(i)->contents_scale() ==
@@ -578,7 +566,7 @@ size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
 }
 
 float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
-  float skewport_target_time_in_frames = ShouldUseGpuRasterization()
+  float skewport_target_time_in_frames = use_gpu_rasterization()
                                              ? kGpuSkewportTargetTimeInFrames
                                              : kCpuSkewportTargetTimeInFrames;
   return skewport_target_time_in_frames *
@@ -605,7 +593,7 @@ gfx::Size PictureLayerImpl::CalculateTileSize(
       layer_tree_impl()->resource_provider()->max_texture_size();
 
   gfx::Size default_tile_size = layer_tree_impl()->settings().default_tile_size;
-  if (ShouldUseGpuRasterization()) {
+  if (use_gpu_rasterization()) {
     // TODO(ernstm) crbug.com/365877: We need a unified way to override the
     // default-tile-size.
     default_tile_size =
@@ -921,7 +909,7 @@ PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(pile_->HasRecordings());
 
   if (twin_layer_ &&
-      twin_layer_->ShouldUseGpuRasterization() == ShouldUseGpuRasterization())
+      twin_layer_->use_gpu_rasterization() == use_gpu_rasterization())
     twin_layer_->SyncTiling(tiling);
 
   return tiling;
@@ -1040,7 +1028,7 @@ bool PictureLayerImpl::ShouldAdjustRasterScale(
 
   if (animating_transform_to_screen &&
       raster_contents_scale_ != ideal_contents_scale_ &&
-      ShouldUseGpuRasterization())
+      use_gpu_rasterization())
     return true;
 
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
@@ -1140,7 +1128,7 @@ void PictureLayerImpl::RecalculateRasterScales(
   // If we're not re-rasterizing during animation, rasterize at the maximum
   // scale that will occur during the animation, if the maximum scale is
   // known.
-  if (animating_transform_to_screen && !ShouldUseGpuRasterization()) {
+  if (animating_transform_to_screen && !use_gpu_rasterization()) {
     if (maximum_animation_contents_scale > 0.f) {
       raster_contents_scale_ =
           std::max(raster_contents_scale_, maximum_animation_contents_scale);
@@ -1330,7 +1318,7 @@ void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const {
   }
   state->Set("coverage_tiles", coverage_tiles.release());
   state->SetBoolean("is_using_lcd_text", is_using_lcd_text_);
-  state->SetBoolean("using_gpu_rasterization", ShouldUseGpuRasterization());
+  state->SetBoolean("using_gpu_rasterization", use_gpu_rasterization());
 }
 
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {

cc/layers/picture_layer_impl.h

@@ -14,6 +14,7 @@
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/picture_layer_tiling_set.h"
 #include "cc/resources/picture_pile_impl.h"
+#include "cc/trees/layer_tree_impl.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkPicture.h"
 
@@ -131,8 +132,9 @@ class CC_EXPORT PictureLayerImpl
 
   virtual void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) OVERRIDE;
 
-  void SetUseGpuRasterization(bool use_gpu);
-  bool ShouldUseGpuRasterization() const { return use_gpu_rasterization_; }
+  bool use_gpu_rasterization() const {
+    return layer_tree_impl()->use_gpu_rasterization();
+  }
 
   // Functions used by tile manager.
   void DidUnregisterLayer();
@@ -151,7 +153,7 @@ class CC_EXPORT PictureLayerImpl
   void ManageTilings(bool animating_transform_to_screen,
                      float maximum_animation_contents_scale);
   bool ShouldHaveLowResTiling() const {
-    return should_use_low_res_tiling_ && !ShouldUseGpuRasterization();
+    return should_use_low_res_tiling_ && !use_gpu_rasterization();
   }
   virtual bool ShouldAdjustRasterScale(
       bool animating_transform_to_screen) const;
@@ -212,7 +214,6 @@ class CC_EXPORT PictureLayerImpl
   // after a CalculateContentsScale/ManageTilings.
   bool should_update_tile_priorities_;
   bool should_use_low_res_tiling_;
-  bool use_gpu_rasterization_;
 
   bool layer_needs_to_register_itself_;
 

cc/layers/picture_layer_impl_unittest.cc

@@ -1716,7 +1716,7 @@ TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
   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,
@@ -1729,9 +1729,10 @@ TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
   // 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,
@@ -1947,8 +1948,10 @@ TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForCpuRasterization) {
 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;

cc/trees/layer_tree_host.cc

@@ -348,6 +348,8 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
                                          max_page_scale_factor_);
   sync_tree->SetPageScaleDelta(page_scale_delta / sent_page_scale_delta);
 
+  sync_tree->SetUseGpuRasterization(UseGpuRasterization());
+
   sync_tree->PassSwapPromises(&swap_promise_list_);
 
   host_impl->SetViewportSize(device_viewport_size_);

cc/trees/layer_tree_host_impl.cc

@@ -1806,12 +1806,11 @@ int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
 }
 
 void LayerTreeHostImpl::ReleaseTreeResources() {
-  if (active_tree_->root_layer())
-    SendReleaseResourcesRecursive(active_tree_->root_layer());
-  if (pending_tree_ && pending_tree_->root_layer())
-    SendReleaseResourcesRecursive(pending_tree_->root_layer());
-  if (recycle_tree_ && recycle_tree_->root_layer())
-    SendReleaseResourcesRecursive(recycle_tree_->root_layer());
+  active_tree_->ReleaseResources();
+  if (pending_tree_)
+    pending_tree_->ReleaseResources();
+  if (recycle_tree_)
+    recycle_tree_->ReleaseResources();
 
   EvictAllUIResources();
 }
@@ -2883,17 +2882,6 @@ base::TimeDelta LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
   return base::TimeDelta::FromSeconds(1);
 }
 
-void LayerTreeHostImpl::SendReleaseResourcesRecursive(LayerImpl* current) {
-  DCHECK(current);
-  current->ReleaseResources();
-  if (current->mask_layer())
-    SendReleaseResourcesRecursive(current->mask_layer());
-  if (current->replica_layer())
-    SendReleaseResourcesRecursive(current->replica_layer());
-  for (size_t i = 0; i < current->children().size(); ++i)
-    SendReleaseResourcesRecursive(current->children()[i]);
-}
-
 std::string LayerTreeHostImpl::LayerTreeAsJson() const {
   std::string str;
   if (active_tree_->root_layer()) {

cc/trees/layer_tree_host_impl.h

@@ -516,7 +516,6 @@ class CC_EXPORT LayerTreeHostImpl
   // the frame should be drawn.
   DrawSwapReadbackResult::DrawResult CalculateRenderPasses(FrameData* frame);
 
-  void SendReleaseResourcesRecursive(LayerImpl* current);
   bool EnsureRenderSurfaceLayerList();
   void ClearCurrentlyScrollingLayer();
 

cc/trees/layer_tree_host_unittest.cc

@@ -5053,7 +5053,7 @@ class LayerTreeHostTestGpuRasterizationDefault : public LayerTreeHostTest {
     PictureLayerImpl* layer_impl =
         static_cast<PictureLayerImpl*>(root->children()[0]);
 
-    EXPECT_FALSE(layer_impl->ShouldUseGpuRasterization());
+    EXPECT_FALSE(layer_impl->use_gpu_rasterization());
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -5061,7 +5061,7 @@ class LayerTreeHostTestGpuRasterizationDefault : public LayerTreeHostTest {
     PictureLayerImpl* layer_impl =
         static_cast<PictureLayerImpl*>(root->children()[0]);
 
-    EXPECT_FALSE(layer_impl->ShouldUseGpuRasterization());
+    EXPECT_FALSE(layer_impl->use_gpu_rasterization());
     EndTest();
   }
 
@@ -5124,7 +5124,7 @@ class LayerTreeHostTestGpuRasterizationEnabled : public LayerTreeHostTest {
     PictureLayerImpl* layer_impl =
         static_cast<PictureLayerImpl*>(root->children()[0]);
 
-    EXPECT_FALSE(layer_impl->ShouldUseGpuRasterization());
+    EXPECT_FALSE(layer_impl->use_gpu_rasterization());
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -5132,7 +5132,7 @@ class LayerTreeHostTestGpuRasterizationEnabled : public LayerTreeHostTest {
     PictureLayerImpl* layer_impl =
         static_cast<PictureLayerImpl*>(root->children()[0]);
 
-    EXPECT_FALSE(layer_impl->ShouldUseGpuRasterization());
+    EXPECT_FALSE(layer_impl->use_gpu_rasterization());
     EndTest();
   }
 
@@ -5195,7 +5195,7 @@ class LayerTreeHostTestGpuRasterizationForced : public LayerTreeHostTest {
     PictureLayerImpl* layer_impl =
         static_cast<PictureLayerImpl*>(root->children()[0]);
 
-    EXPECT_TRUE(layer_impl->ShouldUseGpuRasterization());
+    EXPECT_TRUE(layer_impl->use_gpu_rasterization());
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -5203,7 +5203,7 @@ class LayerTreeHostTestGpuRasterizationForced : public LayerTreeHostTest {
     PictureLayerImpl* layer_impl =
         static_cast<PictureLayerImpl*>(root->children()[0]);
 
-    EXPECT_TRUE(layer_impl->ShouldUseGpuRasterization());
+    EXPECT_TRUE(layer_impl->use_gpu_rasterization());
     EndTest();
   }
 

cc/trees/layer_tree_impl.cc

@@ -92,6 +92,7 @@ LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       scrolling_layer_id_from_previous_tree_(0),
+      use_gpu_rasterization_(false),
       contents_textures_purged_(false),
       requires_high_res_to_draw_(false),
       viewport_size_invalid_(false),
@@ -110,6 +111,11 @@ LayerTreeImpl::~LayerTreeImpl() {
 
 void LayerTreeImpl::Shutdown() { root_layer_.reset(); }
 
+void LayerTreeImpl::ReleaseResources() {
+  if (root_layer_)
+    ReleaseResourcesRecursive(root_layer_.get());
+}
+
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   if (inner_viewport_scroll_layer_)
     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
@@ -220,6 +226,8 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   target_tree->set_background_color(background_color());
   target_tree->set_has_transparent_background(has_transparent_background());
 
+  target_tree->use_gpu_rasterization_ = use_gpu_rasterization();
+
   if (ContentsTexturesPurged())
     target_tree->SetContentsTexturesPurged();
   else
@@ -437,6 +445,14 @@ void LayerTreeImpl::ClearViewportLayers() {
   outer_viewport_scroll_layer_ = NULL;
 }
 
+void LayerTreeImpl::SetUseGpuRasterization(bool use_gpu) {
+  if (use_gpu == use_gpu_rasterization_)
+    return;
+
+  use_gpu_rasterization_ = use_gpu;
+  ReleaseResources();
+}
+
 void LayerTreeImpl::UpdateDrawProperties() {
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
@@ -995,4 +1011,15 @@ const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest()
   return layers_with_copy_output_request_;
 }
 
+void LayerTreeImpl::ReleaseResourcesRecursive(LayerImpl* current) {
+  DCHECK(current);
+  current->ReleaseResources();
+  if (current->mask_layer())
+    ReleaseResourcesRecursive(current->mask_layer());
+  if (current->replica_layer())
+    ReleaseResourcesRecursive(current->replica_layer());
+  for (size_t i = 0; i < current->children().size(); ++i)
+    ReleaseResourcesRecursive(current->children()[i]);
+}
+
 }  // namespace cc

cc/trees/layer_tree_impl.h

@@ -59,6 +59,7 @@ class CC_EXPORT LayerTreeImpl {
   virtual ~LayerTreeImpl();
 
   void Shutdown();
+  void ReleaseResources();
 
   // Methods called by the layer tree that pass-through or access LTHI.
   // ---------------------------------------------------------------------------
@@ -163,6 +164,9 @@ class CC_EXPORT LayerTreeImpl {
   }
   float sent_page_scale_delta() const { return sent_page_scale_delta_; }
 
+  void SetUseGpuRasterization(bool use_gpu);
+  bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
+
   // Updates draw properties and render surface layer list, as well as tile
   // priorities.
   void UpdateDrawProperties();
@@ -250,6 +254,7 @@ class CC_EXPORT LayerTreeImpl {
 
  protected:
   explicit LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl);
+  void ReleaseResourcesRecursive(LayerImpl* current);
 
   LayerTreeHostImpl* layer_tree_host_impl_;
   int source_frame_number_;
@@ -286,6 +291,7 @@ class CC_EXPORT LayerTreeImpl {
   // frame. Used for rendering and input event hit testing.
   LayerImplList render_surface_layer_list_;
 
+  bool use_gpu_rasterization_;
   bool contents_textures_purged_;
   bool requires_high_res_to_draw_;
   bool viewport_size_invalid_;