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 423 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::UpdateTiles(
-    const Occlusion& occlusion_in_content_space) {
+void PictureLayerImpl::UpdateTiles(const Occlusion& occlusion_in_content_space,
+                                   bool draw_properties_valid) {

[danakj, 2014/10/01 02:05:14]

nit: this name seems like a bit of a like, like the screen_space_transform() is
still used for instance. or what do you think? maybe
visible_content_rect_is_valid? or can you explain why this name is suitable?

[danakj, 2014/10/01 02:05:37]

a bit of a lie* i mean

[boliu, 2014/10/01 02:14:58]

Umm, external_draw_constraints_invalid? But only the "draw" constraints are
invalid: transform, viewport, clip.

[danakj, 2014/10/01 02:23:42]

From the POV of this function it seems like the viewport is always valid. If an
external viewport is set, it'll use it no matter what this bool says. I don't
see clip in here anywhere, where do I look for that?

[boliu, 2014/10/01 02:28:47]

I was referring to LTHI::SetExternalDrawConstraints parameters. |viewport|,
|clip|, and |transform| are used for draws and can't be used here. Of course the
two "_for_tile_priority" parameters are ok.

visible_content_rect() is derived from |viewport|. Anything else in draw
properties that are derived from the "external draw constraints" are not ok
either, in theory.

And I guess this also means we should
s/SetExternalDrawConstraints/SetExternalConstraints/

   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 (draw_properties_valid) {
+    visible_rect_for_tile_priority_ = visible_content_rect();
+  }
   viewport_rect_for_tile_priority_ =
       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();
@@ skipping 336 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;
 
+  gfx::Rect rect = GetViewportForTilePriorityInContentSpace();
+  rect.Intersect(visible_rect_for_tile_priority_);
+
   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());
     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