[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/debug/trace_event_argument.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/rendering_stats_instrumentation.h"
+#include "cc/debug/smoothness_timing_tracker.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"
 #include "cc/layers/scrollbar_layer_impl_base.h"
@@ skipping 200 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())),
+      smoothness_tracker_(SmoothnessTimingTracker::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 597 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 =
+            it->smoothness_timing_requests();
+        if (vec.size()) {
+          gfx::Rect damage =
+              root_surface->damage_tracker()->current_damage_rect();
+
+          gfx::Transform inverse_screen_space_transform(
+              gfx::Transform::kSkipInitialization);
+          if (it->screen_space_transform().GetInverse(
+                  &inverse_screen_space_transform))
+            damage = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
+                inverse_screen_space_transform,
+                root_surface->damage_tracker()->current_damage_rect()));
+
+          std::cout << "[LayerTreeHostImpl] it->id() " << it->id()
+                    << " it->damage = [" << damage.x() << ", " << damage.y()
+                    << ", " << damage.right() << ", " << damage.bottom() << "]"
+                    << std::endl;
+          for (size_t i = 0; i < vec.size(); ++i) {
+            int64_t rect_id = vec[i].first;
+            gfx::Rect rect = gfx::ScaleToEnclosingRect(
+                vec[i].second, it->contents_scale_x(), it->contents_scale_y());
+            bool intersects = damage.Intersects(rect);
+            std::cout << "[LayerTreeHostImpl]     Target " << rect_id
+                      << (intersects ? " Intersects " : " Misses ") << " - ["
+                      << rect.x() << ", " << rect.y() << ", " << rect.width()
+                      << ", " << rect.height() << "]" << std::endl;
+            if (intersects) {
+              uncommitted_composite_ids_.push_back(
+                  std::make_pair(active_tree_->source_frame_number(), rect_id));
+            }
+          }
+        }
       }
-
       ++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 621 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_composite_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();
 
+  smoothness_tracker_->SaveTimeStamps(gfx::FrameTime::Now(),
+                                      uncommitted_composite_ids_);
+  uncommitted_composite_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 1769 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