cc: Rename VSync to BeginFrame

cc/trees/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/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 34 matching lines @@
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_(layer_tree_host),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
       weak_factory_on_impl_thread_(this),
       weak_factory_(this),
-      begin_frame_completion_event_on_impl_thread_(NULL),
+      begin_frame_sent_to_main_thread_completion_event_on_impl_thread_(NULL),
       readback_request_on_impl_thread_(NULL),
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
-      render_vsync_enabled_(layer_tree_host->settings().render_vsync_enabled),
-      render_vsync_notification_enabled_(
-          layer_tree_host->settings().render_vsync_notification_enabled),
-      synchronously_disable_vsync_(
-          layer_tree_host->settings().synchronously_disable_vsync),
+      throttle_frame_production_(
+          layer_tree_host->settings().throttle_frame_production),
+      render_parent_drives_begin_frame__(
+          layer_tree_host->settings().render_parent_drives_begin_frame_),
+      using_synchronous_renderer_compositor_(
+          layer_tree_host->settings().using_synchronous_renderer_compositor),
       vsync_client_(NULL),
       inside_draw_(false),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
 }
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(!started_);
 }
 
 bool ThreadProxy::CompositeAndReadback(void* pixels, gfx::Rect rect) {
   TRACE_EVENT0("cc", "ThreadProxy::CompositeAndReadback");
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
   DCHECK(!defer_commits_);
 
   if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded()) {
     TRACE_EVENT0("cc", "CompositeAndReadback_EarlyOut_LR_Uninitialized");
     return false;
   }
 
   // Perform a synchronous commit.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    CompletionEvent begin_frame_completion;
+    CompletionEvent begin_frame_sent_to_main_thread_completion;
     Proxy::ImplThread()->PostTask(
-        base::Bind(&ThreadProxy::ForceBeginFrameOnImplThread,
+        base::Bind(&ThreadProxy::ForceCommitOnImplThread,
                    impl_thread_weak_ptr_,
-                   &begin_frame_completion));
-    begin_frame_completion.Wait();
+                   &begin_frame_sent_to_main_thread_completion));
+    begin_frame_sent_to_main_thread_completion.Wait();
   }
   in_composite_and_readback_ = true;
-  BeginFrame(scoped_ptr<BeginFrameAndCommitState>());
+  BeginFrameOnMainThread(scoped_ptr<BeginFrameAndCommitState>());
   in_composite_and_readback_ = false;
 
   // Perform a synchronous readback.
   ReadbackRequest request;
   request.rect = rect;
   request.pixels = pixels;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     Proxy::ImplThread()->PostTask(
         base::Bind(&ThreadProxy::RequestReadbackOnImplThread,
                    impl_thread_weak_ptr_,
                    &request));
     request.completion.Wait();
   }
   return request.success;
 }
 
+void ThreadProxy::ForceCommitOnImplThread(CompletionEvent* completion) {
+  TRACE_EVENT0("cc", "ThreadProxy::ForceCommitOnImplThread");
+  DCHECK(IsImplThread());
+  DCHECK(!begin_frame_sent_to_main_thread_completion_event_on_impl_thread_);
+
+  scheduler_on_impl_thread_->SetNeedsForcedCommit();
+  if (scheduler_on_impl_thread_->CommitPending()) {
+    completion->Signal();
+    return;
+  }
+
+  begin_frame_sent_to_main_thread_completion_event_on_impl_thread_ = completion;
+}
+
 void ThreadProxy::RequestReadbackOnImplThread(ReadbackRequest* request) {
   DCHECK(Proxy::IsImplThread());
   DCHECK(!readback_request_on_impl_thread_);
   if (!layer_tree_host_impl_) {
     request->success = false;
     request->completion.Signal();
     return;
   }
 
   readback_request_on_impl_thread_ = request;
@@ skipping 192 matching lines @@
   DCHECK(IsImplThread());
   TRACE_EVENT2("cc",
                "ThreadProxy::OnVSyncParametersChanged",
                "timebase",
                (timebase - base::TimeTicks()).InMilliseconds(),
                "interval",
                interval.InMilliseconds());
   scheduler_on_impl_thread_->SetTimebaseAndInterval(timebase, interval);
 }
 
-void ThreadProxy::DidVSync(base::TimeTicks frame_time) {
+void ThreadProxy::BeginFrameOnImplThread(base::TimeTicks frame_time) {
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::DidVSync");
+  TRACE_EVENT0("cc", "ThreadProxy::OnBeginFrameOnImplThread");
   if (vsync_client_)
     vsync_client_->DidVSync(frame_time);
 }
 
 void ThreadProxy::RequestVSyncNotification(VSyncClient* client) {
   DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::RequestVSyncNotification", "enable", !!client);
   vsync_client_ = client;
-  layer_tree_host_impl_->EnableVSyncNotification(!!client);
+  layer_tree_host_impl_->SetNeedsBeginFrame(!!client);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   scheduler_on_impl_thread_->SetCanDraw(can_draw);
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
       !scheduler_on_impl_thread_->WillDrawIfNeeded());
 }
@@ skipping 21 matching lines @@
   manage_tiles_pending_ = true;
 }
 
 void ThreadProxy::ManageTilesOnImplThread() {
   // TODO(nduca): If needed, move this into CCSchedulerStateMachine.
   manage_tiles_pending_ = false;
   if (layer_tree_host_impl_)
     layer_tree_host_impl_->ManageTiles();
 }
 
-void ThreadProxy::SetNeedsForcedCommitOnImplThread() {
-  DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::SetNeedsForcedCommitOnImplThread");
-  scheduler_on_impl_thread_->SetNeedsForcedCommit();
-}
-
 void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events,
     base::Time wall_clock_time) {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc",
                "ThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   Proxy::MainThread()->PostTask(base::Bind(&ThreadProxy::SetAnimationEvents,
                                            main_thread_weak_ptr_,
                                            base::Passed(&events),
                                            wall_clock_time));
@@ skipping 71 matching lines @@
   DCHECK_NE(defer_commits_, defer_commits);
   defer_commits_ = defer_commits;
 
   if (defer_commits_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::SetDeferCommits", this);
   else
     TRACE_EVENT_ASYNC_END0("cc", "ThreadProxy::SetDeferCommits", this);
 
   if (!defer_commits_ && pending_deferred_commit_)
     Proxy::MainThread()->PostTask(
-        base::Bind(&ThreadProxy::BeginFrame,
+        base::Bind(&ThreadProxy::BeginFrameOnMainThread,
                    main_thread_weak_ptr_,
                    base::Passed(&pending_deferred_commit_)));
 }
 
 bool ThreadProxy::CommitRequested() const {
   DCHECK(IsMainThread());
   return commit_requested_;
 }
 
 void ThreadProxy::SetNeedsRedrawOnImplThread() {
@@ skipping 105 matching lines @@
   completion->Signal();
 }
 
 void ThreadProxy::FinishAllRenderingOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::FinishAllRenderingOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_->FinishAllRendering();
   completion->Signal();
 }
 
-void ThreadProxy::ForceBeginFrameOnImplThread(CompletionEvent* completion) {
-  TRACE_EVENT0("cc", "ThreadProxy::ForceBeginFrameOnImplThread");
-  DCHECK(!begin_frame_completion_event_on_impl_thread_);
-
-  SetNeedsForcedCommitOnImplThread();
-  if (scheduler_on_impl_thread_->CommitPending()) {
-    completion->Signal();
-    return;
-  }
-
-  begin_frame_completion_event_on_impl_thread_ = completion;
-}
-
-void ThreadProxy::ScheduledActionBeginFrame() {
-  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionBeginFrame");
+void ThreadProxy::ScheduledActionSendBeginFrameToMainThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionSendBeginFrameToMainThread");
   scoped_ptr<BeginFrameAndCommitState> begin_frame_state(
       new BeginFrameAndCommitState);
   begin_frame_state->monotonic_frame_begin_time = base::TimeTicks::Now();
-  begin_frame_state->scroll_info = layer_tree_host_impl_->ProcessScrollDeltas();
+  begin_frame_state->scroll_info =
+      layer_tree_host_impl_->ProcessScrollDeltas();
   DCHECK_GT(layer_tree_host_impl_->memory_allocation_limit_bytes(), 0u);
   begin_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
-  Proxy::MainThread()->PostTask(base::Bind(&ThreadProxy::BeginFrame,
-                                           main_thread_weak_ptr_,
-                                           base::Passed(&begin_frame_state)));
+  Proxy::MainThread()->PostTask(
+      base::Bind(&ThreadProxy::BeginFrameOnMainThread,
+                 main_thread_weak_ptr_,
+                 base::Passed(&begin_frame_state)));
 
-  if (begin_frame_completion_event_on_impl_thread_) {
-    begin_frame_completion_event_on_impl_thread_->Signal();
-    begin_frame_completion_event_on_impl_thread_ = NULL;
+  if (begin_frame_sent_to_main_thread_completion_event_on_impl_thread_) {
+    begin_frame_sent_to_main_thread_completion_event_on_impl_thread_->Signal();
+    begin_frame_sent_to_main_thread_completion_event_on_impl_thread_ = NULL;
   }
 }
 
-void ThreadProxy::BeginFrame(
+void ThreadProxy::BeginFrameOnMainThread(
     scoped_ptr<BeginFrameAndCommitState> begin_frame_state) {
-  TRACE_EVENT0("cc", "ThreadProxy::BeginFrame");
+  TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnMainThread");
   DCHECK(IsMainThread());
   if (!layer_tree_host_)
     return;
 
   if (defer_commits_) {
     pending_deferred_commit_ = begin_frame_state.Pass();
     layer_tree_host_->DidDeferCommit();
     TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
     return;
   }
@@ skipping 13 matching lines @@
 
   if (begin_frame_state)
     layer_tree_host_->ApplyScrollAndScale(*begin_frame_state->scroll_info);
 
   if (!in_composite_and_readback_ && !layer_tree_host_->visible()) {
     commit_requested_ = false;
     commit_request_sent_to_impl_thread_ = false;
 
     TRACE_EVENT0("cc", "EarlyOut_NotVisible");
     Proxy::ImplThread()->PostTask(base::Bind(
-        &ThreadProxy::BeginFrameAbortedOnImplThread, impl_thread_weak_ptr_));
+        &ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
+        impl_thread_weak_ptr_));
     return;
   }
 
   layer_tree_host_->WillBeginFrame();
 
   if (begin_frame_state) {
     layer_tree_host_->UpdateClientAnimations(
         begin_frame_state->monotonic_frame_begin_time);
     layer_tree_host_->AnimateLayers(
         begin_frame_state->monotonic_frame_begin_time);
@@ skipping 11 matching lines @@
   // Clear the commit flag after updating animations and layout here --- objects
   // that only layout when painted will trigger another SetNeedsCommit inside
   // UpdateLayers.
   commit_requested_ = false;
   commit_request_sent_to_impl_thread_ = false;
 
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
   layer_tree_host_->UpdateLayers(
       queue.get(),
-      begin_frame_state ? begin_frame_state->memory_allocation_limit_bytes
-                        : 0u);
+      begin_frame_state ?
+          begin_frame_state->memory_allocation_limit_bytes : 0u);
 
   // Once single buffered layers are committed, they cannot be modified until
   // they are drawn by the impl thread.
   textures_acquired_ = false;
 
   layer_tree_host_->WillCommit();
   // Before applying scrolls and calling animate, we set animate_requested_ to
   // false. If it is true now, it means SetNeedAnimate was called again, but
   // during a state when commit_request_sent_to_impl_thread_ = true. We need to
   // force that call to happen again now so that the commit request is sent to
   // the impl thread.
   if (animate_requested_) {
     // Forces SetNeedsAnimate to consider posting a commit task.
     animate_requested_ = false;
     SetNeedsAnimate();
   }
 
   scoped_refptr<cc::ContextProvider> offscreen_context_provider;
   if (renderer_capabilities_main_thread_copy_.using_offscreen_context3d &&
       layer_tree_host_->needs_offscreen_context()) {
     offscreen_context_provider = layer_tree_host_->client()->
         OffscreenContextProviderForCompositorThread();
     if (offscreen_context_provider)
       created_offscreen_context_provider_ = true;
   }
 
-  // Notify the impl thread that the BeginFrame has completed. This will
+  // Notify the impl thread that the main thread is ready to commit. This will
   // begin the commit process, which is blocking from the main thread's
   // point of view, but asynchronously performed on the impl thread,
   // coordinated by the Scheduler.
   {
-    TRACE_EVENT0("cc", "ThreadProxy::BeginFrame::commit");
+    TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnMainThread::commit");
 
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
     base::TimeTicks start_time = stats_instrumentation->StartRecording();
 
     CompletionEvent completion;
     Proxy::ImplThread()->PostTask(
-        base::Bind(&ThreadProxy::BeginFrameCompleteOnImplThread,
+        base::Bind(&ThreadProxy::StartCommitOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    queue.release(),
                    offscreen_context_provider));
     completion.Wait();
 
     base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
     stats_instrumentation->AddCommit(duration);
   }
 
   layer_tree_host_->CommitComplete();
   layer_tree_host_->DidBeginFrame();
 }
 
-void ThreadProxy::BeginFrameCompleteOnImplThread(
+void ThreadProxy::StartCommitOnImplThread(
     CompletionEvent* completion,
     ResourceUpdateQueue* raw_queue,
     scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
   scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
 
-  TRACE_EVENT0("cc", "ThreadProxy::BeginFrameCompleteOnImplThread");
+  TRACE_EVENT0("cc", "ThreadProxy::StartCommitOnImplThread");
   DCHECK(!commit_completion_event_on_impl_thread_);
   DCHECK(IsImplThread() && IsMainThreadBlocked());
   DCHECK(scheduler_on_impl_thread_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
 
   if (!layer_tree_host_impl_) {
     TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
     completion->Signal();
     return;
   }
@@ skipping 22 matching lines @@
   if (layer_tree_host_impl_->resource_provider()) {
     current_resource_update_controller_on_impl_thread_ =
         ResourceUpdateController::Create(
             this,
             Proxy::ImplThread(),
             queue.Pass(),
             layer_tree_host_impl_->resource_provider());
     current_resource_update_controller_on_impl_thread_->PerformMoreUpdates(
         scheduler_on_impl_thread_->AnticipatedDrawTime());
   } else {
-    // Normally the ResourceUpdateController notifies when begin frame has
-    // completed, but in tile-free software rendering there is no resource
+    // Normally the ResourceUpdateController notifies when commit should
+    // finish, but in tile-free software rendering there is no resource
     // update step so jump straight to the notification.
-    scheduler_on_impl_thread_->BeginFrameComplete();
+    scheduler_on_impl_thread_->FinishCommit();
   }
 }
 
-void ThreadProxy::BeginFrameAbortedOnImplThread() {
-  TRACE_EVENT0("cc", "ThreadProxy::BeginFrameAbortedOnImplThread");
+void ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread() {
+  TRACE_EVENT0("cc", "ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(scheduler_on_impl_thread_);
   DCHECK(scheduler_on_impl_thread_->CommitPending());
 
-  scheduler_on_impl_thread_->BeginFrameAborted();
+  scheduler_on_impl_thread_->BeginFrameAbortedByMainThread();
 }
 
 void ThreadProxy::ScheduledActionCommit() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(commit_completion_event_on_impl_thread_);
   if (current_resource_update_controller_on_impl_thread_) {
     // Complete all remaining texture updates.
     current_resource_update_controller_on_impl_thread_->Finalize();
     current_resource_update_controller_on_impl_thread_.reset();
@@ skipping 102 matching lines @@
     if (layer_tree_host_impl_->PrepareToDraw(&frame, readback_rect) ||
         forced_draw)
       draw_frame = true;
     else
       start_ready_animations = false;
   }
 
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
-        scheduler_on_impl_thread_->LastVSyncTime());
+        scheduler_on_impl_thread_->LastBeginFrameOnImplThreadTime());
     result.did_draw = true;
   }
   layer_tree_host_impl_->DidDrawAllLayers(frame);
 
   layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
   // Check for a pending CompositeAndReadback.
   if (readback_request_on_impl_thread_) {
     readback_request_on_impl_thread_->success = false;
     if (draw_frame) {
@@ skipping 75 matching lines @@
 
 void ThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
   if (current_resource_update_controller_on_impl_thread_)
     current_resource_update_controller_on_impl_thread_
         ->PerformMoreUpdates(time);
   layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
 }
 
 void ThreadProxy::ReadyToFinalizeTextureUpdates() {
   DCHECK(IsImplThread());
-  scheduler_on_impl_thread_->BeginFrameComplete();
+  scheduler_on_impl_thread_->FinishCommit();
 }
 
 void ThreadProxy::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   if (!layer_tree_host_)
     return;
   layer_tree_host_->DidCommitAndDrawFrame();
 }
 
 void ThreadProxy::DidCompleteSwapBuffers() {
@@ skipping 49 matching lines @@
 
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           layer_tree_host_->settings().refresh_rate);
   scoped_ptr<FrameRateController> frame_rate_controller;
-  if (render_vsync_enabled_) {
-    if (render_vsync_notification_enabled_) {
+  if (throttle_frame_production_) {
+    if (render_parent_drives_begin_frame__) {
       frame_rate_controller.reset(
           new FrameRateController(VSyncTimeSource::Create(
               this,
-              synchronously_disable_vsync_ ?
+              using_synchronous_renderer_compositor_ ?
                   VSyncTimeSource::DISABLE_SYNCHRONOUSLY :
                   VSyncTimeSource::DISABLE_ON_NEXT_TICK)));
     } else {
       frame_rate_controller.reset(
           new FrameRateController(DelayBasedTimeSource::Create(
               display_refresh_interval, Proxy::ImplThread())));
     }
   } else {
     frame_rate_controller.reset(new FrameRateController(Proxy::ImplThread()));
   }
@@ skipping 65 matching lines @@
   if (layer_tree_host_impl_->resource_provider())
     layer_tree_host_impl_->resource_provider()->Finish();
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
-  layer_tree_host_impl_->EnableVSyncNotification(false);
+  layer_tree_host_impl_->SetNeedsBeginFrame(false);
   scheduler_on_impl_thread_.reset();
   layer_tree_host_impl_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
   vsync_client_ = NULL;
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
@@ skipping 140 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation(
       layer_tree_host_impl_->CurrentFrameTimeTicks());
 }
 
-void ThreadProxy::DidReceiveLastInputEventForVSync(
+void ThreadProxy::DidReceiveLastInputEventForBeginFrameOnImplThread(
     base::TimeTicks frame_time) {
-  if (render_vsync_notification_enabled_) {
-    TRACE_EVENT0("cc", "ThreadProxy::DidReceiveLastInputEventForVSync");
-    DidVSync(frame_time);
+  if (render_parent_drives_begin_frame__) {
+    TRACE_EVENT0("cc",
+        "ThreadProxy::DidReceiveLastInputEventForBeginFrameOnImplThread");
+    BeginFrameOnImplThread(frame_time);
   }
 }
 
 void ThreadProxy::DidActivatePendingTree() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidActivatePendingTreeOnImplThread");
 
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
 }  // namespace cc