cc: Use visible_rect_for_tile_priority_ where approriate

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 <set>
 
@@ skipping 431 matching lines @@
 }
 
 void PictureLayerImpl::UpdateTiles(
     const Occlusion& occlusion_in_content_space) {
   TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTiles");
   DCHECK_EQ(1.f, contents_scale_x());
   DCHECK_EQ(1.f, contents_scale_y());
 
   DoPostCommitInitializationIfNeeded();
 
-  visible_rect_for_tile_priority_ = visible_content_rect();
+  if (!layer_tree_impl()->resourceless_software_draw()) {

[danakj, 2014/09/30 21:06:37]

can we pass this to UpdateTiles instead of making it call back to LayerTreeImpl,
where it just came from?

[boliu, 2014/09/30 23:52:02]

This is *not* done yet in PS3. Looks like going to involve a bit of churn, so
gonna do it on top of PS3 and see how this goes.

+    visible_rect_for_tile_priority_ = visible_content_rect();
+  }
   viewport_rect_for_tile_priority_ =

[danakj, 2014/09/30 20:38:37]

the assign before this is completely overridden here, do you mean if else, or
what's going on here?

[danakj, 2014/09/30 20:39:03]

oh visible/viewport, reading how does it work?

       layer_tree_impl()->ViewportRectForTilePriority();
   screen_space_transform_for_tile_priority_ = screen_space_transform();
 
   if (!CanHaveTilings()) {
     ideal_page_scale_ = 0.f;
     ideal_device_scale_ = 0.f;
     ideal_contents_scale_ = 0.f;
     ideal_source_scale_ = 0.f;
     SanityCheckTilingState();
     return;
@@ skipping 335 matching lines @@
 void PictureLayerImpl::MarkVisibleResourcesAsRequired() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
   DCHECK(ideal_contents_scale_);
   DCHECK_GT(tilings_->num_tilings(), 0u);
 
   // The goal of this function is to find the minimum set of tiles that need to
   // be ready to draw in order to activate without flashing content from a
   // higher res on the active tree to a lower res on the pending tree.
 
   // First, early out for layers with no visible content.
-  if (visible_content_rect().IsEmpty())
+  if (visible_rect_for_tile_priority_.IsEmpty())
     return;
 
   // Only mark tiles inside the viewport for tile priority as required for
   // activation. This viewport is normally the same as the draw viewport but
   // can be independently overridden by embedders like Android WebView with
   // SetExternalDrawConstraints.
   gfx::Rect rect = GetViewportForTilePriorityInContentSpace();
-  rect.Intersect(visible_content_rect());
+  rect.Intersect(visible_rect_for_tile_priority_);
 
   float min_acceptable_scale =
       std::min(raster_contents_scale_, ideal_contents_scale_);
 
   if (PictureLayerImpl* twin = twin_layer_) {
     float twin_min_acceptable_scale =
         std::min(twin->ideal_contents_scale_, twin->raster_contents_scale_);
     // Ignore 0 scale in case CalculateContentsScale() has never been
     // called for active twin.
     if (twin_min_acceptable_scale != 0.0f) {
@@ skipping 657 matching lines @@
 bool PictureLayerImpl::AllTilesRequiredForActivationAreReadyToDraw() const {
   if (!layer_tree_impl()->IsPendingTree())
     return true;
 
   if (!HasValidTilePriorities())
     return true;
 
   if (!tilings_)
     return true;
 
-  if (visible_content_rect().IsEmpty())
+  if (visible_rect_for_tile_priority_.IsEmpty())
     return true;
 
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->resolution() != HIGH_RESOLUTION &&
         tiling->resolution() != LOW_RESOLUTION)
       continue;
 
-    gfx::Rect rect(visible_content_rect());
+    gfx::Rect rect(visible_rect_for_tile_priority_);

[danakj, 2014/09/30 21:05:53]

Why isn't this using GetViewportForTilePriorityInContentSpace() intersect this
rect, like when we mark required? can you explain either way the background for
this decision? Maybe this should be a comment if it should be different from
marking.

[boliu, 2014/09/30 22:37:48]

omg this is an existing bug! It should be
GetViewportForTilePriorityInContentSpace afaict. I missed this method when in
this change, when I changed the activation rect in
https://codereview.chromium.org/475233002/

Looks like no one has noticed yet...

     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
          ++iter) {
       const Tile* tile = *iter;
       // A null tile (i.e. missing recording) can just be skipped.
       if (!tile)
         continue;
 
       if (tile->required_for_activation() && !tile->IsReadyToDraw())
         return false;
     }
@@ skipping 270 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc