[cc] Trace detailed tile info when --trace-all-rendered-frames

cc/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/picture_layer_tiling.h"
 
 #include "cc/math_util.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/safe_integer_conversions.h"
@@ skipping 417 matching lines @@
       float time_to_visible_in_seconds =
           TilePriority::TimeForBoundsToIntersect(
               last_screen_rect, current_screen_rect, time_delta, view_rect);
       float distance_to_visible_in_pixels =
           TilePriority::manhattanDistance(current_screen_rect, view_rect);
 
       TilePriority priority(
           resolution_,
           time_to_visible_in_seconds,
           distance_to_visible_in_pixels);
+      bool clipped;
+      priority.set_current_screen_quad(
+          MathUtil::projectQuad(current_screen_transform,

[shawnsingh, 2013/02/01 19:39:22]

First, are you sure we want project here?  This is mapping "forward" from local
space to screen, so map should be good enough.  (If mapQuad doesn't exist, we
can consider adding it back, I may have left it out for now to make sure we dont
use it for non-debugging code and shoot ourselves in the foot with more clipping
issues)

Second, yeah this will definitely hurt performance.  Is it possible to pull all
this out into a completely separate walk through tiles that does not get called
unless we want to serialize?

Otherwise, maybe we need to for now just #define it.  I'm still unfamiliar with
the tile priority code, but I suspect this is pretty hot code path and even an
if (serializeStuff) condition might be worth avoiding, right?

+                                gfx::QuadF(tile_bounds),
+                                clipped));
       tile->set_priority(tree, priority);
     }
   }
   else
   {
     for (TilingData::Iterator iter(&tiling_data_, inflated_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
       if (find == tiles_.end())
         continue;
@@ skipping 17 matching lines @@
       float time_to_visible_in_seconds =
           TilePriority::TimeForBoundsToIntersect(
               last_screen_rect, current_screen_rect, time_delta, view_rect);
       float distance_to_visible_in_pixels =
           TilePriority::manhattanDistance(current_screen_rect, view_rect);
 
       TilePriority priority(
           resolution_,
           time_to_visible_in_seconds,
           distance_to_visible_in_pixels);
+      bool clipped;
+      priority.set_current_screen_quad(
+          MathUtil::projectQuad(current_screen_transform,
+                                gfx::QuadF(tile_bounds),
+                                clipped));
       tile->set_priority(tree, priority);
     }
   }
 
   last_source_frame_number_ = current_source_frame_number;
   last_impl_frame_time_ = current_frame_time;
 }
 
 void PictureLayerTiling::DidBecomeActive() {
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     it->second->set_priority(ACTIVE_TREE, it->second->priority(PENDING_TREE));
     it->second->set_priority(PENDING_TREE, TilePriority());
 
     // Tile holds a ref onto a picture pile. If the tile never gets invalidated
     // and recreated, then that picture pile ref could exist indefinitely.  To
     // prevent this, ask the client to update the pile to its own ref.  This
     // will cause PicturePileImpls and their clones to get deleted once the
     // corresponding PictureLayerImpl and any in flight raster jobs go out of
     // scope.
     client_->UpdatePile(it->second);
   }
 }
 
 }  // namespace cc