cc: Use BeginFrameArgs

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 "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 87 matching lines @@
     // construct a DebugScopedSetImplThread object. There is no need to do
     // 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()));
     }
 
-    // TODO(enne): This should probably happen post-animate.
-    if (layer_tree_host_impl_->pending_tree()) {
-      layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
+    if (layer_tree_host_impl_->settings().impl_side_painting) {
+      layer_tree_host_impl_->BeginFrame(
+          BeginFrameArgs::CreateExpiredForTesting());
+    } else {
+      if (layer_tree_host_impl_->pending_tree()) {
+        layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
 
-      if (layer_tree_host_impl_->pending_tree()) {
-        layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
-        layer_tree_host_impl_->ManageTiles();
+        if (layer_tree_host_impl_->pending_tree()) {
+          layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
+          layer_tree_host_impl_->ManageTiles();
+        }
       }
+
+      layer_tree_host_impl_->Animate(
+          layer_tree_host_impl_->CurrentFrameTimeTicks(),
+          layer_tree_host_impl_->CurrentFrameTime());
+      layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
+      bool start_ready_animations = true;
+      layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
+      layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
     }
-
-    layer_tree_host_impl_->Animate(
-        layer_tree_host_impl_->CurrentFrameTimeTicks(),
-        layer_tree_host_impl_->CurrentFrameTime());
-    layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
-    bool start_ready_animations = true;
-    layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
-    layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
   }
 
   void SetActive(bool active) {
     if (active != time_source_->Active())
       time_source_->SetActive(active);
   }
 
  private:
   LayerTreeHostImplTimeSourceAdapter(
       LayerTreeHostImpl* layer_tree_host_impl,
@@ skipping 154 matching lines @@
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   return true;
 }
 
 void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time,
                                 base::Time wall_clock_time) {
+  TRACE_EVENT0("cc", __FUNCTION__);
   if (input_handler_client_)
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time, wall_clock_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::ManageTiles() {
   if (!tile_manager_)
@@ skipping 12 matching lines @@
   SendManagedMemoryStats(memory_required_bytes,
                          memory_nice_to_have_bytes,
                          memory_used_bytes);
 }
 
 void LayerTreeHostImpl::StartPageScaleAnimation(gfx::Vector2d target_offset,
                                                 bool anchor_point,
                                                 float page_scale,
                                                 base::TimeTicks start_time,
                                                 base::TimeDelta duration) {
+  TRACE_EVENT0("cc", __FUNCTION__);
   if (!RootScrollLayer())
     return;
 
   gfx::Vector2dF scroll_total =
       RootScrollLayer()->scroll_offset() + RootScrollLayer()->ScrollDelta();
   gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
   gfx::SizeF viewport_size = VisibleViewportSize();
 
   double start_time_seconds = (start_time - base::TimeTicks()).InSecondsF();
 
@@ skipping 422 matching lines @@
   if (input_handler_client_)
     input_handler_client_->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHostImpl::UpdateBackgroundAnimateTicking(
     bool should_background_tick) {
   DCHECK(proxy_->IsImplThread());
 
   bool enabled = should_background_tick &&
                  !animation_registrar_->active_animation_controllers().empty();
-
+  if (animation_registrar_->active_animation_controllers().empty()) {
+    TRACE_EVENT0("cc", "animation_registrar_->active_animation_controllers().empty() == true");
+  }
   // Lazily create the time_source adapter so that we can vary the interval for
   // testing.
   if (!time_source_client_adapter_) {
     time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
         this,
         DelayBasedTimeSource::Create(
             LowFrequencyAnimationInterval(),
             proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                                     : proxy_->MainThreadTaskRunner()));
   }
@@ skipping 597 matching lines @@
   TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
                                    active_tree_->root_layer());
   DCHECK(!recycle_tree_);
 
   pending_tree_->PushPropertiesTo(active_tree_.get());
 
   // Now that we've synced everything from the pending tree to the active
   // tree, rename the pending tree the recycle tree so we can reuse it on the
   // next sync.
   pending_tree_.swap(recycle_tree_);
+  client_->DidActivatePendingTree();
   recycle_tree_->ClearRenderSurfaces();
 
   active_tree_->SetRootLayerScrollOffsetDelegate(
       root_layer_scroll_offset_delegate_);
   active_tree_->DidBecomeActive();
 
   // Reduce wasted memory now that unlinked resources are guaranteed not
   // to be used.
   client_->ReduceWastedContentsTextureMemoryOnImplThread();
 
   client_->OnCanDrawStateChanged(CanDraw());
   client_->OnHasPendingTreeStateChanged(pending_tree_);
   client_->SetNeedsRedrawOnImplThread();
   client_->RenewTreePriority();
 
   if (debug_state_.continuous_painting) {
     const RenderingStats& stats =
         rendering_stats_instrumentation_->GetRenderingStats();
     paint_time_counter_->SavePaintTime(
         stats.total_paint_time + stats.total_record_time +
             stats.total_rasterize_time_for_now_bins_on_pending_tree);
   }
 
-  client_->DidActivatePendingTree();
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
@@ skipping 844 matching lines @@
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
   current_frame_timeticks_ = base::TimeTicks();
   current_frame_time_ = base::Time();
 }
 
 void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks,
                                                base::Time* now) const {
   if (ticks->is_null()) {
     DCHECK(now->is_null());
+    TRACE_EVENT0("cc", "UpdateCurrentFrameTime");
     *ticks = CurrentPhysicalTimeTicks();
     *now = base::Time::Now();
   }
 }
 
 base::TimeTicks LayerTreeHostImpl::CurrentFrameTimeTicks() {
   UpdateCurrentFrameTime(&current_frame_timeticks_, &current_frame_time_);
   return current_frame_timeticks_;
 }
 
@@ skipping 55 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc