cc: Simplify picture layer tiling update tile priorities.

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 321 matching lines @@
   if (!tiling_needs_update)
     return;
 
   UpdateLCDTextStatus(can_use_lcd_text());
 
   gfx::Transform current_screen_space_transform = screen_space_transform();
 
   gfx::Size viewport_size = layer_tree_impl()->DrawViewportSize();
   gfx::Rect viewport_in_content_space;
   gfx::Transform screen_to_layer(gfx::Transform::kSkipInitialization);
   if (screen_space_transform().GetInverse(&screen_to_layer)) {

[enne (OOO), 2014/01/31 23:33:36]

Maybe we only need this projection if the viewport_in_content_space is empty? 
Also, if the viewport in content space is empty, then that means that the layer
is clipped away.  Right now (and previously) we'd mark those tiles as visible if
they were clipped away but also inside the projection of the viewport.

If we substitute the projected viewport for the viewport in content space,
should we skip marking anything as NOW and just mark everything in the skewport
+ viewport as SOON?

[vmpstr, 2014/02/03 20:27:24]

Done.
I'd prefer to keep this as now for now. My reasoning being that it more closely
resembles current behaviour. On top of that, piping through the fact we replaced
the rect requires extra plumbing. Given that this is more of an optimization,
I'd prefer to leave that for a follow-up. Wdyt?

     viewport_in_content_space =
         gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
             screen_to_layer, gfx::Rect(viewport_size)));
   }
 
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
   size_t max_tiles_for_interest_area =
       layer_tree_impl()->settings().max_tiles_for_interest_area;
   tilings_->UpdateTilePriorities(
       tree,
-      viewport_size,
       viewport_in_content_space,
       visible_content_rect(),
-      last_bounds_,
-      bounds(),
-      last_content_scale_,
       contents_scale_x(),
-      last_screen_space_transform_,
-      current_screen_space_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
   if (layer_tree_impl()->IsPendingTree())
     MarkVisibleResourcesAsRequired();
 
   last_screen_space_transform_ = current_screen_space_transform;

[enne (OOO), 2014/01/31 23:33:36]

Do we need this still?

[vmpstr, 2014/02/03 20:27:24]

Nope. Removed.

   last_bounds_ = bounds();
   last_content_scale_ = contents_scale_x();
 
   // Tile priorities were modified.
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
 void PictureLayerImpl::DidBecomeActive() {
   LayerImpl::DidBecomeActive();
   tilings_->DidBecomeActive();
@@ skipping 339 matching lines @@
                                                    contents_scale_x(),
                                                    rect);
          iter;
          ++iter) {
       if (!*iter || !iter->IsReadyToDraw())
         continue;
 
       // This iteration is over the visible content rect which is potentially
       // less conservative than projecting the viewport into the layer.
       // Ignore tiles that are know to be outside the viewport.
-      if (iter->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
+      if (iter->priority(PENDING_TREE).distance_to_visible != 0)

[enne (OOO), 2014/01/31 23:33:36]

I think this can go away as we only mark tiles in the visible content rect as
visible and this loop is only iterating over tiles in that rect.

[vmpstr, 2014/02/03 20:27:24]

Good point. Done.

         continue;
 
       missing_region.Subtract(iter.geometry_rect());
       iter->MarkRequiredForActivation();
     }
   }
   DCHECK(high_res) << "There must be one high res tiling";
 
   // If these pointers are null (because no twin, no matching tiling, or the
   // simpification just below), then high res tiles will be required to fill any
@@ skipping 48 matching lines @@
        iter;
        ++iter) {
     Tile* tile = *iter;
     // A null tile (i.e. missing recording) can just be skipped.
     if (!tile)
       continue;
 
     // This iteration is over the visible content rect which is potentially
     // less conservative than projecting the viewport into the layer.
     // Ignore tiles that are know to be outside the viewport.
-    if (tile->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
+    if (tile->priority(PENDING_TREE).distance_to_visible != 0)
       continue;
 
     // If the missing region doesn't cover it, this tile is fully
     // covered by acceptable tiles at other scales.
     if (!missing_region.Intersects(iter.geometry_rect()))
       continue;
 
     // If the twin tile doesn't exist (i.e. missing recording or so far away
     // that it is outside the visible tile rect) or this tile is shared between
     // with the twin, then this tile isn't required to prevent flashing.
@@ skipping 422 matching lines @@
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc