Remove current implementation of frame timing events.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 222 matching lines @@
       output_is_secure_(false),
       animation_host_(),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       task_graph_runner_(task_graph_runner),
       id_(id),
       requires_high_res_to_draw_(false),
       is_likely_to_require_a_draw_(false),
-      frame_timing_tracker_(FrameTimingTracker::Create(this)),
       mutator_(nullptr) {
   animation_host_ = AnimationHost::Create(ThreadInstance::IMPL);
   animation_host_->SetMutatorHostClient(this);
   animation_host_->SetSupportsScrollAnimations(SupportsImplScrolling());
 
   DCHECK(task_runner_provider_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
@@ skipping 639 matching lines @@
     } else if (it.represents_itself() && !it->visible_layer_rect().IsEmpty()) {
       bool occluded =
           it->draw_properties().occlusion_in_content_space.IsOccluded(
               it->visible_layer_rect());
       if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
         DCHECK_EQ(active_tree_.get(), it->layer_tree_impl());
 
         frame->will_draw_layers.push_back(*it);
 
         it->AppendQuads(target_render_pass, &append_quads_data);
-
-        // For layers that represent themselves, add composite frame timing
-        // requests if the visible rect intersects the requested rect.
-        for (const auto& request : it->frame_timing_requests()) {
-          if (request.rect().Intersects(it->visible_layer_rect())) {
-            frame->composite_events.push_back(
-                FrameTimingTracker::FrameAndRectIds(
-                    active_tree_->source_frame_number(), request.id()));
-          }
-        }
       }
 
       ++layers_drawn;
     }
 
     rendering_stats_instrumentation_->AddVisibleContentArea(
         append_quads_data.visible_layer_area);
     rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
         append_quads_data.approximated_visible_content_area);
     rendering_stats_instrumentation_->AddCheckerboardedVisibleContentArea(
@@ skipping 681 matching lines @@
 
   return metadata;
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
 
   base::TimeTicks frame_begin_time = CurrentBeginFrameArgs().frame_time;
   DCHECK(CanDraw());
 
-  if (!frame->composite_events.empty()) {
-    frame_timing_tracker_->SaveTimeStamps(frame_begin_time,
-                                          frame->composite_events);
-  }
-
   if (frame->has_no_damage) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!resourceless_software_draw_);
     return;
   }
 
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time,
                               !output_surface_->context_provider());
@@ skipping 614 matching lines @@
   int max_copy_texture_chromium_size = context_provider->ContextCapabilities()
                                            .gpu.max_copy_texture_chromium_size;
 
   *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
       GetTaskRunner(), task_graph_runner, context_provider,
       resource_provider_.get(), max_copy_texture_chromium_size,
       settings_.use_partial_raster, settings_.max_staging_buffer_usage_in_bytes,
       settings_.renderer_settings.preferred_tile_format);
 }
 
-void LayerTreeHostImpl::RecordMainFrameTiming(
-    const BeginFrameArgs& start_of_main_frame_args,
-    const BeginFrameArgs& expected_next_main_frame_args) {
-  std::vector<int64_t> request_ids;
-  active_tree_->GatherFrameTimingRequestIds(&request_ids);
-  if (request_ids.empty())
-    return;
-
-  base::TimeTicks start_time = start_of_main_frame_args.frame_time;
-  base::TimeTicks end_time = expected_next_main_frame_args.frame_time;
-  frame_timing_tracker_->SaveMainFrameTimeStamps(
-      request_ids, start_time, end_time, active_tree_->source_frame_number());
-}
-
-void LayerTreeHostImpl::PostFrameTimingEvents(
-    std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-    std::unique_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
-  client_->PostFrameTimingEventsOnImplThread(std::move(composite_events),
-                                             std::move(main_frame_events));
-}
-
 void LayerTreeHostImpl::SetLayerTreeMutator(LayerTreeMutator* mutator) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeHostImpl::SetLayerTreeMutator");
   mutator_ = mutator;
 }
 
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
@@ skipping 1696 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc