Rename Animate as Begin(Main)Frame

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 <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 143 matching lines @@
     // this in multi-threaded mode since the real thread id's will be
     // correct. In fact, setting fake thread id's interferes with the real
     // thread id's and causes breakage.
     scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
     if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
       set_impl_thread.reset(
           new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
     }
 
     layer_tree_host_impl_->Animate(
-        layer_tree_host_impl_->CurrentFrameTimeTicks());
+        layer_tree_host_impl_->CurrentBeginFrameArgs().frame_time);

[mithro-old, 2014/08/11 07:33:33]

An example of the Animate verse BeginFrame here?

It sounds like people want to rip out this background ticking though in
http://code.google.com/p/chromium/issues/detail?id=371747 

[Sami, 2014/08/11 17:51:26]

We chatted about this and came to the conclusion that let's keep this level of
Animate/BeginFrame separation until we have a good reason to do something about
it (and figure out what to do with background ticking).

     layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
     if (layer_tree_host_impl_->pending_tree()) {
       layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
       layer_tree_host_impl_->ManageTiles();
     }
 
     layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
@@ skipping 1490 matching lines @@
 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
   if (output_surface_)
     output_surface_->SetNeedsBeginFrame(enable);
   else
     DCHECK(!enable);
 }
 
 void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
   // Sample the frame time now. This time will be used for updating animations
   // when we draw.
-  UpdateCurrentFrameTime();
+  UpdateCurrentFrameTime(args);
   // Cache the begin impl frame interval
   begin_impl_frame_interval_ = args.interval;

[mithro-old, 2014/08/11 07:33:33]

Should we log a bug to remove this value now it's stored in the args too?

[Sami, 2014/08/11 17:51:26]

It doesn't look like it's completely redundant since current_begin_frame_args_
gets reset often.

 }
 
 gfx::SizeF LayerTreeHostImpl::ComputeInnerViewportContainerSize() const {
   gfx::SizeF dip_size =
       gfx::ScaleSize(device_viewport_size_, 1.f / device_scale_factor());
 
   float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
 
   return gfx::SizeF(dip_size.width(),
@@ skipping 698 matching lines @@
     if (!animation)
       return ScrollIgnored;
 
     ScrollOffsetAnimationCurve* curve =
         animation->curve()->ToScrollOffsetAnimationCurve();
 
     gfx::Vector2dF new_target = curve->target_value() + scroll_delta;
     new_target.SetToMax(gfx::Vector2dF());
     new_target.SetToMin(layer_impl->MaxScrollOffset());
 
-    curve->UpdateTarget(
-        animation->TrimTimeToCurrentIteration(CurrentFrameTimeTicks()),
-        new_target);
+    curve->UpdateTarget(animation->TrimTimeToCurrentIteration(
+                            CurrentBeginFrameArgs().frame_time),
+                        new_target);
 
     return ScrollStarted;
   }
   // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
   // behavior as ScrollBy to determine which layer to animate, but we do not
   // do the Android-specific things in ScrollBy like showing top controls.
   InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
   if (scroll_status == ScrollStarted) {
     gfx::Vector2dF pending_delta = scroll_delta;
     for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
@@ skipping 738 matching lines @@
 void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
   if (!tile_manager_)
     return;
 
   if (global_tile_state_.tree_priority == priority)
     return;
   global_tile_state_.tree_priority = priority;
   DidModifyTilePriorities();
 }
 
-void LayerTreeHostImpl::UpdateCurrentFrameTime() {
-  DCHECK(current_frame_timeticks_.is_null());
-  current_frame_timeticks_ = gfx::FrameTime::Now();
+void LayerTreeHostImpl::UpdateCurrentFrameTime(const BeginFrameArgs& args) {

[mithro-old, 2014/08/11 07:33:33]

UpdateCurrentFrameTime previously didn't take arguments; in this CL I think we
should keep that consistent?

[Sami, 2014/08/11 17:51:26]

Now that this is called UpdateCurrentBeginFrameArgs I think it makes to pass the
args here. WDYT?

+  DCHECK(!current_begin_frame_args_.IsValid());
+  current_begin_frame_args_ = args;
+  current_begin_frame_args_.frame_time = gfx::FrameTime::Now();

[mithro-old, 2014/08/11 07:33:33]

Can we add a comment about this now usage. It's going to cause a WTF any time
someone new sees it.

[Sami, 2014/08/11 17:51:26]

Can you suggest something to write, because I don't know why we override the
time like this anyway? :) Maybe it needs a TODO saying this is wrong?

 }
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
-  current_frame_timeticks_ = base::TimeTicks();
+  current_begin_frame_args_ = BeginFrameArgs();
 }
 
-base::TimeTicks LayerTreeHostImpl::CurrentFrameTimeTicks() {
+BeginFrameArgs LayerTreeHostImpl::CurrentBeginFrameArgs() const {
   // Try to use the current frame time to keep animations non-jittery.  But if
   // we're not in a frame (because this is during an input event or a delayed
   // task), fall back to physical time.  This should still be monotonic.
-  if (!current_frame_timeticks_.is_null())
-    return current_frame_timeticks_;
-  return gfx::FrameTime::Now();
+  if (current_begin_frame_args_.IsValid())
+    return current_begin_frame_args_;
+  return BeginFrameArgs::Create(gfx::FrameTime::Now(),
+                                base::TimeTicks(),
+                                BeginFrameArgs::DefaultInterval());

[mithro-old, 2014/08/11 07:33:33]

I'm still trying to make this go away :(

 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 LayerTreeHostImpl::AsValue() const {
   return AsValueWithFrame(NULL);
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
   scoped_refptr<base::debug::TracedValue> state =
@@ skipping 188 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc