cc: Record statistics about approximated content.

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 220 matching lines @@
   for (PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     gfx::Rect visible_geometry_rect =
         quad_sink->UnoccludedContentRect(geometry_rect, draw_transform());
     if (visible_geometry_rect.IsEmpty())
       continue;
 
+    append_quads_data->visible_content_area +=
+        visible_geometry_rect.width() * visible_geometry_rect.height();
+
     if (!*iter || !iter->IsReadyToDraw()) {
       if (draw_checkerboard_for_missing_tiles()) {
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
         SkColor color = DebugColors::DefaultCheckerboardColor();
         quad->SetNew(
             shared_quad_state, geometry_rect, visible_geometry_rect, color);
         quad_sink->Append(quad.PassAs<DrawQuad>());
       } else {
         SkColor color = SafeOpaqueBackgroundColor();
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(shared_quad_state,
                      geometry_rect,
                      visible_geometry_rect,
                      color,
                      false);
         quad_sink->Append(quad.PassAs<DrawQuad>());
       }
 
       append_quads_data->num_missing_tiles++;
       append_quads_data->had_incomplete_tile = true;
+      append_quads_data->approximated_visible_content_area +=
+          visible_geometry_rect.width() * visible_geometry_rect.height();
       continue;
     }
 
     const ManagedTileState::TileVersion& tile_version =
         iter->GetTileVersionForDrawing();
     scoped_ptr<DrawQuad> draw_quad;
     switch (tile_version.mode()) {
       case ManagedTileState::TileVersion::RESOURCE_MODE: {
         gfx::RectF texture_rect = iter.texture_rect();
         gfx::Rect opaque_rect = iter->opaque_rect();
@@ skipping 45 matching lines @@
                      tile_version.get_solid_color(),
                      false);
         draw_quad = quad.PassAs<DrawQuad>();
         break;
       }
     }
 
     DCHECK(draw_quad);
     quad_sink->Append(draw_quad.Pass());
 
+    if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {

[enne (OOO), 2014/04/29 17:38:41]

This is not entirely right.  You could be using a non ideal resolution tile of a
scale less than high resolution too.

[ernstm, 2014/04/29 18:40:14]

I changed this to != HIGH_RESOLUTION. That should capture all approximated
cases, right?

[enne (OOO), 2014/04/29 18:46:38]

You can sometimes have a non-ideal resolution that's higher than high resolution
in the case of a zoom in.  I'd call that not approximated, but it's up to you.

[ernstm, 2014/04/29 19:00:12]

I assume we need to resample/interpolate in that case, which can result in
artifacts. It's not really an approximation, but it is different than the ideal
result.

+      append_quads_data->approximated_visible_content_area +=
+          visible_geometry_rect.width() * visible_geometry_rect.height();
+    }
+
     if (seen_tilings.empty() || seen_tilings.back() != iter.CurrentTiling())
       seen_tilings.push_back(iter.CurrentTiling());
   }
 
   // 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);
 }
@@ skipping 1181 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc