Remove current implementation of frame timing events.

cc/trees/proxy_impl.cc

 // Copyright 2015 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/proxy_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 170 matching lines @@
     CommitEarlyOutReason reason,
     base::TimeTicks main_thread_start_time) {
   TRACE_EVENT1("cc", "ProxyImpl::BeginMainFrameAbortedOnImplThread", "reason",
                CommitEarlyOutReasonToString(reason));
   DCHECK(IsImplThread());
   DCHECK(scheduler_->CommitPending());
   DCHECK(!layer_tree_host_impl_->pending_tree());
 
   if (CommitEarlyOutHandledCommit(reason)) {
     SetInputThrottledUntilCommitOnImpl(false);
-    last_processed_begin_main_frame_args_ = last_begin_main_frame_args_;
   }
   layer_tree_host_impl_->BeginMainFrameAborted(reason);
   scheduler_->NotifyBeginMainFrameStarted(main_thread_start_time);
   scheduler_->BeginMainFrameAborted(reason);
 }
 
 void ProxyImpl::FinishAllRenderingOnImpl(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ProxyImpl::FinishAllRenderingOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_->FinishAllRendering();
@@ skipping 247 matching lines @@
   DCHECK(IsImplThread());
 
   if (next_commit_waits_for_activation_) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(commit_completion_event_);
     commit_completion_event_->Signal();
     commit_completion_event_ = nullptr;
     next_commit_waits_for_activation_ = false;
   }
-
-  last_processed_begin_main_frame_args_ = last_begin_main_frame_args_;
 }
 
 void ProxyImpl::WillPrepareTiles() {
   DCHECK(IsImplThread());
   scheduler_->WillPrepareTiles();
 }
 
 void ProxyImpl::DidPrepareTiles() {
   DCHECK(IsImplThread());
   scheduler_->DidPrepareTiles();
 }
 
 void ProxyImpl::DidCompletePageScaleAnimationOnImplThread() {
   DCHECK(IsImplThread());
   channel_impl_->DidCompletePageScaleAnimation();
 }
 
 void ProxyImpl::OnDrawForOutputSurface(bool resourceless_software_draw) {
   DCHECK(IsImplThread());
   scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
 }
 
-void ProxyImpl::PostFrameTimingEventsOnImplThread(
-    std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-    std::unique_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
-  DCHECK(IsImplThread());
-  channel_impl_->PostFrameTimingEventsOnMain(std::move(composite_events),
-                                             std::move(main_frame_events));
-}
-
 void ProxyImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
   DCHECK(IsImplThread());
   layer_tree_host_impl_->WillBeginImplFrame(args);
-  if (last_processed_begin_main_frame_args_.IsValid()) {
-    // Last processed begin main frame args records the frame args that we sent
-    // to the main thread for the last frame that we've processed. If that is
-    // set, that means the current frame is one past the frame in which we've
-    // finished the processing.
-    layer_tree_host_impl_->RecordMainFrameTiming(
-        last_processed_begin_main_frame_args_, args);
-    last_processed_begin_main_frame_args_ = BeginFrameArgs();
-  }
 }
 
 void ProxyImpl::DidFinishImplFrame() {
   DCHECK(IsImplThread());
   layer_tree_host_impl_->DidFinishImplFrame();
 }
 
 void ProxyImpl::ScheduledActionSendBeginMainFrame(const BeginFrameArgs& args) {
   DCHECK(IsImplThread());
   unsigned int begin_frame_id = nextBeginFrameId++;
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
       benchmark_instrumentation::kSendBeginFrame, begin_frame_id);
   std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state(
       new BeginMainFrameAndCommitState);
   begin_main_frame_state->begin_frame_id = begin_frame_id;
   begin_main_frame_state->begin_frame_args = args;
   begin_main_frame_state->begin_frame_callbacks =
       layer_tree_host_impl_->ProcessLayerTreeMutations();
   begin_main_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
   begin_main_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
   begin_main_frame_state->evicted_ui_resources =
       layer_tree_host_impl_->EvictedUIResourcesExist();
-  // TODO(vmpstr): This needs to be fixed if
-  // main_frame_before_activation_enabled is set, since we might run this code
-  // twice before recording a duration. crbug.com/469824
-  last_begin_main_frame_args_ = begin_main_frame_state->begin_frame_args;
   channel_impl_->BeginMainFrame(std::move(begin_main_frame_state));
   devtools_instrumentation::DidRequestMainThreadFrame(layer_tree_host_id_);
 }
 
 DrawResult ProxyImpl::ScheduledActionDrawAndSwapIfPossible() {
   TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionDrawAndSwap");
   DCHECK(IsImplThread());
 
   // SchedulerStateMachine::DidDrawIfPossibleCompleted isn't set up to
   // handle DRAW_ABORTED_CANT_DRAW.  Moreover, the scheduler should
@@ skipping 145 matching lines @@
 bool ProxyImpl::IsMainThreadBlocked() const {
   return task_runner_provider_->IsMainThreadBlocked();
 }
 
 ProxyImpl::BlockedMainCommitOnly& ProxyImpl::blocked_main_commit() {
   DCHECK(IsMainThreadBlocked() && commit_completion_event_);
   return main_thread_blocked_commit_vars_unsafe_;
 }
 
 }  // namespace cc