cc: ReadyToDraw notifications.

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 675 matching lines @@
     tile_query_rect =
         gfx::ScaleToEnclosingRect(tile_query_rect, 1.0f / contents_scale_);
   }
 
   return current_occlusion_in_layer_space_.IsOccluded(tile_query_rect);
 }
 
 bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
   DCHECK_EQ(PENDING_TREE, client_->GetTree());
 
   // Note that although this function will determine whether tile is required

[vmpstr, 2014/10/24 18:02:24]

Can you remove "although" here (while here :) )

[ernstm, 2014/10/27 21:13:56]

Done.

   // for activation assuming that it is in visible (ie in the viewport). That is
   // to say, even if the tile is outside of the viewport, it will be treated as
   // if it was inside (there are no explicit checks for this). Hence, this
   // function is only called for visible tiles to ensure we don't block
   // activation on tiles outside of the viewport.
 
   // If we are not allowed to mark tiles as required for activation, then don't
   // do it.
   if (!can_require_tiles_for_activation_)
     return false;
@@ skipping 20 matching lines @@
   Tile* twin_tile =
       twin_tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index());
   // If twin tile is missing, it might not have a recording, so we don't need
   // this tile to be required for activation.
   if (!twin_tile)
     return false;
 
   return true;
 }
 
+bool PictureLayerTiling::IsTileRequiredForDraw(const Tile* tile) const {
+  DCHECK_EQ(ACTIVE_TREE, client_->GetTree());
+
+  // Note that although this function will determine whether tile is required

[vmpstr, 2014/10/24 18:02:24]

Same here.

[ernstm, 2014/10/27 21:13:56]

Done.

+  // for draw assuming that it is in visible (ie in the viewport). That is
+  // to say, even if the tile is outside of the viewport, it will be treated as
+  // if it was inside (there are no explicit checks for this). Hence, this
+  // function is only called for visible tiles to ensure we don't block
+  // activation on tiles outside of the viewport.

[vmpstr, 2014/10/24 18:02:24]

This is not correct, this should say something similar about draw.

[enne (OOO), 2014/10/24 19:16:28]

"activation", eh?

I know that this is a copy-paste from IsTileRequiredForActivation.  Could these
be renamed to be like IsTileRequiredForFoobarIfVisible to make it clear that
it's not the final determination?  I think that would help not need this
gigantic comment?

[ernstm, 2014/10/27 21:13:56]

Done.

+
+  if (resolution_ != HIGH_RESOLUTION)
+    return false;
+
+  if (IsTileOccluded(tile))
+    return false;
+
+  return true;
+}
+
 void PictureLayerTiling::UpdateTileAndTwinPriority(Tile* tile) const {
   UpdateTilePriority(tile);
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   if (!tile->is_shared() || !twin_tiling) {
     WhichTree tree = client_->GetTree();
     WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
     tile->SetPriority(twin_tree, TilePriority());
     tile->set_is_occluded(twin_tree, false);
     if (twin_tree == PENDING_TREE)
       tile->set_required_for_activation(false);
+    else
+      tile->set_required_for_draw(false);
     return;
   }
 
   twin_tiling->UpdateTilePriority(tile);
 }
 
 void PictureLayerTiling::UpdateTilePriority(Tile* tile) const {
   // TODO(vmpstr): This code should return the priority instead of setting it on
   // the tile. This should be a part of the change to move tile priority from
   // tiles into iterators.
   WhichTree tree = client_->GetTree();
 
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
   gfx::Rect tile_bounds =
       tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
 
   if (current_visible_rect_.Intersects(tile_bounds)) {
     tile->SetPriority(tree, TilePriority(resolution_, TilePriority::NOW, 0));
     if (tree == PENDING_TREE)
       tile->set_required_for_activation(IsTileRequiredForActivation(tile));
+    else
+      tile->set_required_for_draw(IsTileRequiredForDraw(tile));
     tile->set_is_occluded(tree, IsTileOccluded(tile));
     return;
   }
 
   if (tree == PENDING_TREE)
     tile->set_required_for_activation(false);
+  else
+    tile->set_required_for_draw(false);
   tile->set_is_occluded(tree, false);
 
   DCHECK_GT(content_to_screen_scale_, 0.f);
   float distance_to_visible =
       current_visible_rect_.ManhattanInternalDistance(tile_bounds) *
       content_to_screen_scale_;
 
   if (current_soon_border_rect_.Intersects(tile_bounds) ||
       current_skewport_rect_.Intersects(tile_bounds)) {
     tile->SetPriority(
@@ skipping 439 matching lines @@
   DCHECK(*this);
   do {
     ++current_eviction_tiles_index_;
   } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
            !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
 
   return *this;
 }
 
 }  // namespace cc