Remove current implementation of frame timing events.

cc/layers/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/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 73 matching lines @@
       effect_tree_index_(-1),
       clip_tree_index_(-1),
       scroll_tree_index_(-1),
       draw_depth_(0.f),
       sorting_context_id_(0),
       current_draw_mode_(DRAW_MODE_NONE),
       element_id_(0),
       mutable_properties_(MutableProperty::kNone),
       debug_info_(nullptr),
       force_render_surface_(false),
-      frame_timing_requests_dirty_(false),
       scrolls_drawn_descendant_(false),
       layer_or_descendant_has_touch_handler_(false) {
   DCHECK_GT(layer_id_, 0);
 
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
   layer_tree_impl_->AddToElementMap(this);
 
   SetNeedsPushProperties();
 }
@@ skipping 483 matching lines @@
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
   if (owned_debug_info_)
     layer->SetDebugInfo(std::move(owned_debug_info_));
 
-  if (frame_timing_requests_dirty_) {
-    layer->SetFrameTimingRequests(frame_timing_requests_);
-    frame_timing_requests_dirty_ = false;
-  }
-
   // Reset any state that should be cleared for the next update.
   layer_property_changed_ = false;
   update_rect_ = gfx::Rect();
   layer_tree_impl()->RemoveLayerShouldPushProperties(this);
 }
 
 bool LayerImpl::IsAffectedByPageScale() const {
   TransformTree& transform_tree =
       layer_tree_impl()->property_trees()->transform_tree;
   return transform_tree.Node(transform_tree_index())
@@ skipping 594 matching lines @@
 
   should_flatten_transform_ = flatten;
 }
 
 void LayerImpl::Set3dSortingContextId(int id) {
   if (id == sorting_context_id_)
     return;
   sorting_context_id_ = id;
 }
 
-void LayerImpl::SetFrameTimingRequests(
-    const std::vector<FrameTimingRequest>& requests) {
-  frame_timing_requests_ = requests;
-  frame_timing_requests_dirty_ = true;
-  SetNeedsPushProperties();
-}
-
-void LayerImpl::GatherFrameTimingRequestIds(std::vector<int64_t>* request_ids) {
-  for (const auto& request : frame_timing_requests_)
-    request_ids->push_back(request.id());
-}
-
 void LayerImpl::SetTransform(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
 
   transform_ = transform;
   transform_is_invertible_ = transform_.IsInvertible();
 }
 
 void LayerImpl::SetTransformAndInvertibility(const gfx::Transform& transform,
                                              bool transform_is_invertible) {
@@ skipping 241 matching lines @@
           debug_info_value->GetAsDictionary(&dictionary_value);
       DCHECK(converted_to_dictionary);
       for (base::DictionaryValue::Iterator it(*dictionary_value); !it.IsAtEnd();
            it.Advance()) {
         state->SetValue(it.key().data(), it.value().CreateDeepCopy());
       }
     } else {
       NOTREACHED();
     }
   }
-
-  if (!frame_timing_requests_.empty()) {
-    state->BeginArray("frame_timing_requests");
-    for (const auto& request : frame_timing_requests_) {
-      state->BeginDictionary();
-      state->SetInteger("request_id", request.id());
-      MathUtil::AddToTracedValue("request_rect", request.rect(), state);
-      state->EndDictionary();
-    }
-    state->EndArray();
-  }
 }
 
 bool LayerImpl::IsDrawnRenderSurfaceLayerListMember() const {
   return draw_properties_.last_drawn_render_surface_layer_list_id ==
          layer_tree_impl_->current_render_surface_list_id();
 }
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 void LayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
@@ skipping 122 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc