cc: Adding BeginFrameTracker object and removing Now() from LTHI.

cc/trees/single_thread_proxy.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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 476 matching lines @@
     // RequestNewOutputSurface could have synchronously created an output
     // surface, so check again before returning.
     if (layer_tree_host_->output_surface_lost())
       return;
   }
 
   {
     BeginFrameArgs begin_frame_args(BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, frame_begin_time, base::TimeTicks(),
         BeginFrameArgs::DefaultInterval(), BeginFrameArgs::SYNCHRONOUS));
+    layer_tree_host_impl_->UpdateCurrentBeginFrameArgs(begin_frame_args);
     DoBeginMainFrame(begin_frame_args);
     DoCommit();
 
     DCHECK_EQ(0u, layer_tree_host_->num_queued_swap_promises())
         << "Commit should always succeed and transfer promises.";
   }
 
   {
     DebugScopedSetImplThread impl(const_cast<SingleThreadProxy*>(this));
     if (layer_tree_host_impl_->settings().impl_side_painting) {
       layer_tree_host_impl_->ActivateSyncTree();
       layer_tree_host_impl_->active_tree()->UpdateDrawProperties();
       layer_tree_host_impl_->PrepareTiles();
       layer_tree_host_impl_->SynchronouslyInitializeAllTiles();
     }
 
     DoAnimate();
 
     LayerTreeHostImpl::FrameData frame;
     DoComposite(frame_begin_time, &frame);
 
     // DoComposite could abort, but because this is a synchronous composite
     // another draw will never be scheduled, so break remaining promises.
     layer_tree_host_impl_->active_tree()->BreakSwapPromises(
         SwapPromise::SWAP_FAILS);
+
+    layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
   }
 }
 
 void SingleThreadProxy::AsValueInto(base::debug::TracedValue* state) const {
   // The following line casts away const modifiers because it is just
   // setting debug state. We still want the AsValue() function and its
   // call chain to be const throughout.
   DebugScopedSetImplThread impl(const_cast<SingleThreadProxy*>(this));
 
   state->BeginDictionary("layer_tree_host_impl");
@@ skipping 54 matching lines @@
     timing_history_.DidStartDrawing();
 
     draw_result = layer_tree_host_impl_->PrepareToDraw(frame);
     draw_frame = draw_result == DRAW_SUCCESS;
     if (draw_frame)
       layer_tree_host_impl_->DrawLayers(frame, frame_begin_time);
     layer_tree_host_impl_->DidDrawAllLayers(*frame);
 
     bool start_ready_animations = draw_frame;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
-    layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();

[brianderson, 2014/12/18 02:01:38]

Why does this need to move?

[mithro-old, 2014/12/18 17:22:41]

Because it's currently in the wrong place as code in the STP between this
location and the new location still uses the BFA (as found by tests).

This means currently in production that code is not just getting values affected
by the delay to first BeginFrame, it's getting horrible values which are just
Now() when ever it's called.

 
     timing_history_.DidFinishDrawing();
   }
 
   if (draw_frame) {
     DebugScopedSetImplThread impl(this);
 
     // This CapturePostTasks should be destroyed before
     // DidCommitAndDrawFrame() is called since that goes out to the
     // embedder,
@@ skipping 187 matching lines @@
 
 void SingleThreadProxy::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
 }
 
 void SingleThreadProxy::SendBeginFramesToChildren(const BeginFrameArgs& args) {
   layer_tree_host_->SendBeginFramesToChildren(args);
 }
 
 }  // namespace cc