[not for review] Add Draw entries to window Performance Timeline

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 <iostream>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/latency_info_swap_promise_monitor.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/debug_rect_history.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/paint_time_counter.h"
+#include "cc/debug/performance_draw_timing_counter.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
@@ skipping 191 matching lines @@
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
           gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
           ManagedMemoryPolicy::kDefaultNumResourcesLimit),
       pinch_gesture_active_(false),
       pinch_gesture_end_should_clear_scrolling_layer_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
+      draw_counter_(PerformanceDrawTimingCounter::Create()),
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter(
           proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                                   : proxy_->MainThreadTaskRunner())),
       max_memory_needed_bytes_(0),
       zero_budget_(false),
       device_scale_factor_(1.f),
       overhang_ui_resource_id_(0),
@@ skipping 595 matching lines @@
 
             contributing_render_pass_id =
                 it->NextContributingRenderPassId(contributing_render_pass_id);
           }
         }
 
         AppendQuadsForLayer(target_render_pass,
                             *it,
                             occlusion_tracker,
                             &append_quads_data);
+
+        const std::vector<std::pair<int64_t, gfx::Rect> > &vec =

[enne (OOO), 2014/07/22 20:44:26]

This block of code could probably just get moved into AppendQuadsForalyer.

Also, if you want this to be real, you probably need to store these rects on
quads themselves so that the browser compositor can tell you when they're
actually shown on screen.  I remember discussing that this is a followup, so
maybe you could leave a TODO so it's more obvious that this is not the end
state.

+            it->draw_frame_request_rects();
+        if (vec.size()) {

[enne (OOO), 2014/07/22 20:44:26]

style nit: early out here and continue rather than indenting the whole block
below

[Mike B, 2014/07/25 23:09:41]

Hm, to do that I need to make it a function I can return from. Or I can
'continue' on the loop, but that might not be clear to future developers who try
and add code below mine in the loop.
Suggestions?
On 2014/07/22 20:44:26, enne wrote:

+          gfx::Rect viewport = it->visible_content_rect();

[enne (OOO), 2014/07/22 20:44:26]

bikeshed: This isn't the viewport, it's the viewport projected into the layer's
content space.

[Mike B, 2014/07/25 23:09:41]

Gotcha, I'm just creating that variable to print out the contents to stdout. It
won't exist in the actual patch.

+          std::cout << "[LayerTreeHostImpl] it->id() " << it->id()
+                    << " it->visible_content_rect = ["
+                    << viewport.x() << ", " << viewport.y() << ", "
+                    << viewport.right() << ", " << viewport.bottom() << "]"
+                    << std::endl;
+          for (size_t i = 0; i < vec.size(); ++i) {
+            int64_t rect_id = vec[i].first;
+            bool intersects = it->visible_content_rect().Intersects(

[enne (OOO), 2014/07/22 20:44:26]

visible content rect is in content space (aka layer bounds scaled by
contents_scale()), so you can't compare them directly.  You need to scale one or
the other, take the enclosing content rect to round up to integers, and then
intersect.

[Mike B, 2014/07/25 23:09:41]

Done.

+                vec[i].second);
+            std::cout << "[LayerTreeHostImpl]     Target " << rect_id
+                      << (intersects ? " Intersects " : " Misses ") << " - ["
+                      << vec[i].second.x() << ", " << vec[i].second.y() << ", "
+                      << vec[i].second.width() << ", " << vec[i].second.height()
+                      << "]" << std::endl;
+            if (intersects) {
+              uncommitted_draw_frame_ids_.push_back(

[enne (OOO), 2014/07/22 20:44:26]

This should live on the frame data too and not be a member variable.  Then you
won't have to clear it.

+                  std::make_pair(active_tree_->source_frame_number(), rect_id));

[enne (OOO), 2014/07/22 20:44:26]

How does performance timeline handle getting the same rect ids drawn on
different compositor frames from the same source frame number?

Where does this frame number get used? It looks like the only thing that gets
back up to Blink is an id -> [timestamps] mapping?

[Mike B, 2014/07/25 23:09:41]

It gets 2 entries that have the same source frame but different timestamps.
That's ok.

The source frame number is not actually used, in the current implementation
though.

On 2014/07/22 20:44:26, enne wrote:

+            }
+          }
+        }
       }
-
       ++layers_drawn;
     }
 
     rendering_stats_instrumentation_->AddVisibleContentArea(
         append_quads_data.visible_content_area);
     rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
         append_quads_data.approximated_visible_content_area);
 
     num_missing_tiles += append_quads_data.num_missing_tiles;
     num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
@@ skipping 552 matching lines @@
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
 
   if (frame->has_no_damage) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
+    uncommitted_draw_frame_ids_.clear();
     return;
   }
 
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time,
                               !output_surface_->context_provider());
   bool on_main_thread = false;
   rendering_stats_instrumentation_->IncrementFrameCount(
       1, on_main_thread);
@@ skipping 69 matching lines @@
     renderer_->DrawFrame(&frame->render_passes,
                          device_scale_factor_,
                          DeviceViewport(),
                          DeviceClip(),
                          false);
   }
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
   frame->render_passes_by_id.clear();
 
+  draw_counter_->SaveTimeStamps(CurrentFrameTimeTicks(),
+                                uncommitted_draw_frame_ids_);
+  uncommitted_draw_frame_ids_.clear();
+
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
   // TODO(boliu): If we did a temporary software renderer frame, propogate the
   // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
 
@@ skipping 1731 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