Remove current implementation of frame timing events.

cc/trees/layer_tree_host_impl.h

 // 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_IMPL_H_
 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "cc/animation/layer_tree_mutator.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/synced_property.h"
-#include "cc/debug/frame_timing_tracker.h"
 #include "cc/debug/micro_benchmark_controller_impl.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/scrollbar_animation_controller.h"
 #include "cc/input/top_controls_manager_client.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/renderer.h"
@@ skipping 92 matching lines @@
   virtual void DidActivateSyncTree() = 0;
   virtual void WillPrepareTiles() = 0;
   virtual void DidPrepareTiles() = 0;
 
   // Called when page scale animation has completed on the impl thread.
   virtual void DidCompletePageScaleAnimationOnImplThread() = 0;
 
   // Called when output surface asks for a draw.
   virtual void OnDrawForOutputSurface(bool resourceless_software_draw) = 0;
 
-  virtual void PostFrameTimingEventsOnImplThread(
-      std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-      std::unique_ptr<FrameTimingTracker::MainFrameTimingSet>
-          main_frame_events) = 0;
-
  protected:
   virtual ~LayerTreeHostImplClient() {}
 };
 
 // LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
 // state.
 class CC_EXPORT LayerTreeHostImpl
     : public InputHandler,
       public RendererClient,
       public TileManagerClient,
@@ skipping 66 matching lines @@
 
   void UpdateViewportContainerSizes();
 
   struct CC_EXPORT FrameData : public RenderPassSink {
     FrameData();
     ~FrameData() override;
     void AsValueInto(base::trace_event::TracedValue* value) const;
 
     std::vector<gfx::Rect> occluding_screen_space_rects;
     std::vector<gfx::Rect> non_occluding_screen_space_rects;
-    std::vector<FrameTimingTracker::FrameAndRectIds> composite_events;
     RenderPassList render_passes;
     const LayerImplList* render_surface_layer_list;
     LayerImplList will_draw_layers;
     bool has_no_damage;
 
     // RenderPassSink implementation.
     void AppendRenderPass(std::unique_ptr<RenderPass> render_pass) override;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(FrameData);
@@ skipping 341 matching lines @@
 
   bool SupportsImplScrolling() const;
   bool CommitToActiveTree() const;
 
   virtual void CreateResourceAndTileTaskWorkerPool(
       std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
       std::unique_ptr<ResourcePool>* resource_pool);
 
   bool prepare_tiles_needed() const { return tile_priorities_dirty_; }
 
-  FrameTimingTracker* frame_timing_tracker() {
-    return frame_timing_tracker_.get();
-  }
-
   gfx::Vector2dF ScrollSingleNode(ScrollNode* scroll_node,
                                   const gfx::Vector2dF& delta,
                                   const gfx::Point& viewport_point,
                                   bool is_direct_manipulation,
                                   ScrollTree* scroll_tree);
 
   void set_output_is_secure(bool output_is_secure) {
     output_is_secure_ = output_is_secure;
   }
 
   bool output_is_secure() const { return output_is_secure_; }
 
-  // Record main frame timing information.
-  // |start_of_main_frame_args| is the BeginFrameArgs of the beginning of the
-  // main frame (ie the frame that kicked off the main frame).
-  // |expected_next_main_frame_args| is the BeginFrameArgs of the frame that
-  // follows the completion of the main frame (whether it is activation or some
-  // other completion, such as early out). Note that if there is a main frame
-  // scheduled in that frame, then this BeginFrameArgs will become the main
-  // frame args. However, if no such frame is scheduled, then this _would_ be
-  // the main frame args if it was scheduled.
-  void RecordMainFrameTiming(
-      const BeginFrameArgs& start_of_main_frame_args,
-      const BeginFrameArgs& expected_next_main_frame_args);
-
-  // Post the given frame timing events to the requester.
-  void PostFrameTimingEvents(
-      std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-      std::unique_ptr<FrameTimingTracker::MainFrameTimingSet>
-          main_frame_events);
-
   base::SingleThreadTaskRunner* GetTaskRunner() const {
     DCHECK(task_runner_provider_);
     return task_runner_provider_->HasImplThread()
                ? task_runner_provider_->ImplThreadTaskRunner()
                : task_runner_provider_->MainThreadTaskRunner();
   }
 
   InputHandler::ScrollStatus TryScroll(const gfx::PointF& screen_space_point,
                                        InputHandler::ScrollInputType type,
                                        const ScrollTree& scroll_tree,
@@ skipping 226 matching lines @@
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   TaskGraphRunner* task_graph_runner_;
   int id_;
 
   std::set<SwapPromiseMonitor*> swap_promise_monitor_;
 
   bool requires_high_res_to_draw_;
   bool is_likely_to_require_a_draw_;
 
-  std::unique_ptr<FrameTimingTracker> frame_timing_tracker_;
-
   std::unique_ptr<Viewport> viewport_;
 
   LayerTreeMutator* mutator_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_