Histogram to track missing and incomplete tiles

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 760 matching lines @@
   // still draw the frame. However when the layer being checkerboarded is moving
   // due to an impl-animation, we drop the frame to avoid flashing due to the
   // texture suddenly appearing in the future.
   DrawResult draw_result = DRAW_SUCCESS;
   // When we have a copy request for a layer, we need to draw no matter
   // what, as the layer may disappear after this frame.
   bool have_copy_request = false;
 
   int layers_drawn = 0;
 
+  int num_missing_tiles = 0;
+  int num_incomplete_tiles = 0;
+
   const DrawMode draw_mode = GetDrawMode(output_surface_.get());
 
   LayerIteratorType end =
       LayerIteratorType::End(frame->render_surface_layer_list);
   for (LayerIteratorType it =
            LayerIteratorType::Begin(frame->render_surface_layer_list);
        it != end;
        ++it) {
     RenderPass::Id target_render_pass_id =
         it.target_render_surface_layer()->render_surface()->RenderPassId();
@@ skipping 58 matching lines @@
 
       ++layers_drawn;
     }
 
     rendering_stats_instrumentation_->AddVisibleContentArea(
         append_quads_data.visible_content_area);
     rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
         append_quads_data.approximated_visible_content_area);
 
     if (append_quads_data.num_missing_tiles) {
+      num_missing_tiles += append_quads_data.num_missing_tiles;
       bool layer_has_animating_transform =
           it->screen_space_transform_is_animating() ||
           it->draw_transform_is_animating();
       if (layer_has_animating_transform)
         draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     }
 
-    if (append_quads_data.had_incomplete_tile) {
+    if (append_quads_data.num_incomplete_tiles > 0) {

[danakj, 2014/07/07 20:06:28]

you can still just do if (append_quads_data.num_incomplete_tiles)

.. tho, i think we should do

if (append_quads_data.num_incomplete_tiles ||
append_quads_data.num_missing_tiles)

as per earlier comment

[weiliangc, 2014/07/07 21:50:09]

Do we still want to sum missing_tiles too? As in adding line:
num_incomplete_tiles += aqd.num_missing_tiles;
?

[danakj, 2014/07/07 21:52:01]

I don't think so, then you'd double count them again cuz you wanna know just how
many tiles were the wrong res for this number right?

[weiliangc, 2014/07/07 21:55:34]

Ah, I forgot the parts after += num_incomplete_tiles need to execute when
missing tiles. Got it. Thanks!

[weiliangc, 2014/07/07 22:01:21]

Done.

+      num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
       frame->contains_incomplete_tile = true;
       if (active_tree()->RequiresHighResToDraw())
         draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
     }
 
     occlusion_tracker.LeaveLayer(it);
   }
 
   if (have_copy_request ||
       output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
@@ skipping 30 matching lines @@
   while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
     LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
     layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
   }
   for (size_t i = 0; i < requests_to_abort.size(); ++i)
     requests_to_abort[i]->SendEmptyResult();
 
   // If we're making a frame to draw, it better have at least one render pass.
   DCHECK(!frame->render_passes.empty());
 
+  if (IsCurrentlyScrolling()) {
+    UMA_HISTOGRAM_COUNTS(
+        "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
+        num_missing_tiles);
+    UMA_HISTOGRAM_COUNTS_100(
+        "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
+        num_incomplete_tiles);
+  }
+
   // Should only have one render pass in resourceless software mode.
   if (output_surface_->ForcedDrawToSoftwareDevice())
     DCHECK_EQ(1u, frame->render_passes.size());
 
   return draw_result;
 }
 
 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
   if (input_handler_client_)
     input_handler_client_->MainThreadHasStoppedFlinging();
@@ skipping 2225 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc