cc: Stop pushing properties every activation for picture layers.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 125 matching lines @@
   DCHECK_IMPLIES(raster_source_->IsSolidColor(),
                  layer_impl->tilings_->num_tilings() == 0);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
   layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
 
   layer_impl->SanityCheckTilingState();
-
-  // We always need to push properties.
-  // See http://crbug.com/303943
-  // TODO(danakj): Stop always pushing properties since we don't swap tilings.
-  needs_push_properties_ = true;
 }
 
 void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
                                    const Occlusion& occlusion_in_content_space,
                                    AppendQuadsData* append_quads_data) {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
   DCHECK_IMPLIES(!raster_source_->GetSize().IsEmpty(),
                  bounds() == raster_source_->GetSize())
       << " bounds " << bounds().ToString() << " pile "
@@ skipping 405 matching lines @@
     RemoveAllTilings();
     return;
   }
 
   // We could do this after doing UpdateTiles, which would avoid doing this for
   // tilings that are going to disappear on the pending tree (if scale changed).
   // But that would also be more complicated, so we just do it here for now.
   tilings_->UpdateTilingsToCurrentRasterSource(
       raster_source_, pending_set, invalidation_, MinimumContentsScale(),
       MaximumContentsScale());
+
+  // SetNeedsPushProperties when changing the tiling set or raster source. These
+  // shouldn't imply damage but need to be synced.
+  SetNeedsPushProperties();

[vmpstr, 2015/01/23 20:57:57]

Should this be invoked using PLTS UpdateTilingsToCurrentRasterSource?

[danakj, 2015/01/23 21:11:36]

Only if it added a new tiling to the set.

 }
 
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
   if (layer_tree_impl()->IsActiveTree()) {
     gfx::RectF layer_damage_rect =
         gfx::ScaleRect(tile->content_rect(), 1.f / tile->contents_scale());
     AddDamageRect(layer_damage_rect);
   }
 }
 
 void PictureLayerImpl::DidBeginTracing() {
   raster_source_->DidBeginTracing();
 }
 
 void PictureLayerImpl::ReleaseResources() {
   // Recreate tilings with new settings, since some of those might change when
   // we release resources. If tilings_ is null, then leave it as null.
   if (tilings_)
     tilings_ = CreatePictureLayerTilingSet();
   ResetRasterScale();
 
   // To avoid an edge case after lost context where the tree is up to date but
   // the tilings have not been managed, request an update draw properties
   // to force tilings to get managed.
   layer_tree_impl()->set_needs_update_draw_properties();
+
+  // SetNeedsPushProperties when changing the tiling set or raster source. These
+  // shouldn't imply damage but need to be synced.
+  SetNeedsPushProperties();

[vmpstr, 2015/01/23 20:57:58]

Should this be invoked via PLTS constructor? Or is this push due to raster scale
being reset? If so, can you update the comment?

[danakj, 2015/01/23 21:11:36]

The constructor doesn't add any tilings, and the destructor doesn't call the
client. I could make one of those happen. The push is cuz of the tilings_ being
recreated/assigned.

 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return raster_source_->GetFlattenedPicture();
 }
 
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(
     float contents_scale,
     const gfx::Rect& content_rect) {
   int flags = 0;
@@ skipping 38 matching lines @@
 TilePriority::PriorityBin PictureLayerImpl::GetMaxTilePriorityBin() const {
   if (!HasValidTilePriorities())
     return TilePriority::EVENTUALLY;
   return TilePriority::NOW;
 }
 
 bool PictureLayerImpl::RequiresHighResToDraw() const {
   return layer_tree_impl()->RequiresHighResToDraw();
 }
 
+void PictureLayerImpl::TilingSetChanged() {
+  // SetNeedsPushProperties when changing the tiling set or raster source. These
+  // shouldn't imply damage but need to be synced.
+  SetNeedsPushProperties();
+}
+
 gfx::Size PictureLayerImpl::CalculateTileSize(
     const gfx::Size& content_bounds) const {
   int max_texture_size =
       layer_tree_impl()->resource_provider()->max_texture_size();
 
   if (is_mask_) {
     // Masks are not tiled, so if we can't cover the whole mask with one tile,
     // we shouldn't have such a tiling at all.
     DCHECK_LE(content_bounds.width(), max_texture_size);
     DCHECK_LE(content_bounds.height(), max_texture_size);
@@ skipping 617 matching lines @@
 
 bool PictureLayerImpl::AllTilesRequiredForDrawAreReadyToDraw() const {
   if (!layer_tree_impl()->IsActiveTree())
     return true;
 
   return AllTilesRequiredAreReadyToDraw(
       &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
 }
 
 }  // namespace cc