cc: Refactor how picture layers are exposed to the tile manager.

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 <limits>
 
 #include "base/time/time.h"
@@ skipping 46 matching lines @@
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
       was_animating_transform_to_screen_(false),
       is_using_lcd_text_(tree_impl->settings().can_use_lcd_text),
       needs_post_commit_initialization_(true),
-      should_update_tile_priorities_(false),
-      layer_needs_to_register_itself_(true) {
+      should_update_tile_priorities_(false) {
+  layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
-  if (!layer_needs_to_register_itself_)
-    layer_tree_impl()->tile_manager()->UnregisterPictureLayerImpl(this);
+  layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
 }
 
 scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return PictureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
@@ skipping 282 matching lines @@
                          on_demand_missing_tile_count);
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
   // better scheme would be to maintain a tighter visible_content_rect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(seen_tilings);
 }
 
-void PictureLayerImpl::DidUnregisterLayer() {
-  TRACE_EVENT0("cc", "PictureLayerImpl::DidUnregisterLayer");
-
-  layer_needs_to_register_itself_ = true;
-}
-
 void PictureLayerImpl::UpdateTilePriorities() {
   TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTilePriorities");
 
   DCHECK(!needs_post_commit_initialization_);
   CHECK(should_update_tile_priorities_);
 
-  if (layer_needs_to_register_itself_) {
-    layer_tree_impl()->tile_manager()->RegisterPictureLayerImpl(this);
-    layer_needs_to_register_itself_ = false;
-  }
-
   if (layer_tree_impl()->device_viewport_valid_for_tile_management()) {
     visible_rect_for_tile_priority_ = visible_content_rect();
     viewport_size_for_tile_priority_ = layer_tree_impl()->DrawViewportSize();
     screen_space_transform_for_tile_priority_ = screen_space_transform();
   }
 
   if (!tilings_->num_tilings())
     return;
 
   double current_frame_time_in_seconds =
@@ skipping 982 matching lines @@
 }
 
 WhichTree PictureLayerImpl::GetTree() const {
   return layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 }
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
+bool PictureLayerImpl::IsViableSourceOfRasterAndEvictionTiles() const {

[reveman, 2014/06/05 22:15:18]

What else is needed here? Does UpdateTilePriorities just need to be called once
before this can return true? Or do we need to check if the current version of
tile priorities is a result of the last call to update draw properties and in
case it's not, return false?

[vmpstr, 2014/06/05 22:38:01]

IsDrawnRenderSurfaceLayerListMember being true implies priorities were updated.

You also have to make sure to remove all tiles when the layer is no longer a
part of the render surface layer list, since it still might have tiles with
resources.

[reveman, 2014/06/06 17:27:24]

We'll handle that as discussed. Renamed this function to HasValidTilePriorities
in latest patch.

+  return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
+}
+
 bool PictureLayerImpl::AllTilesRequiredForActivationAreReadyToDraw() const {
   if (!layer_tree_impl()->IsPendingTree())
     return true;
 
   if (!tilings_)
     return true;
 
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->resolution() != HIGH_RESOLUTION &&
@@ skipping 234 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc