cc: Rename SwapBuffers on CompositorFrameSink to SubmitCompositorFrame

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 250 matching lines @@
 void ProxyImpl::SetBeginFrameSource(BeginFrameSource* source) {
   // During shutdown, destroying the CompositorFrameSink may unset the
   // BeginFrameSource.
   if (scheduler_) {
     // TODO(enne): this overrides any preexisting begin frame source.  Those
     // other sources will eventually be removed and this will be the only path.
     scheduler_->SetBeginFrameSource(source);
   }
 }
 
-void ProxyImpl::DidSwapBuffersCompleteOnImplThread() {
-  TRACE_EVENT0("cc,benchmark", "ProxyImpl::DidSwapBuffersCompleteOnImplThread");
+void ProxyImpl::DidReceiveCompositorFrameAckOnImplThread() {
+  TRACE_EVENT0("cc,benchmark",
+               "ProxyImpl::DidReceiveCompositorFrameAckOnImplThread");
   DCHECK(IsImplThread());
-  scheduler_->DidSwapBuffersComplete();
-  channel_impl_->DidCompleteSwapBuffers();
+  scheduler_->DidReceiveCompositorFrameAck();
+  channel_impl_->DidReceiveCompositorFrameAck();
 }
 
 void ProxyImpl::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1("cc", "ProxyImpl::OnCanDrawStateChanged", "can_draw", can_draw);
   DCHECK(IsImplThread());
   scheduler_->SetCanDraw(can_draw);
 }
 
 void ProxyImpl::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "ProxyImpl::NotifyReadyToActivate");
@@ skipping 155 matching lines @@
   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->evicted_ui_resources =
       layer_tree_host_impl_->EvictedUIResourcesExist();
   channel_impl_->BeginMainFrame(std::move(begin_main_frame_state));
   devtools_instrumentation::DidRequestMainThreadFrame(layer_tree_host_id_);
 }
 
-DrawResult ProxyImpl::ScheduledActionDrawAndSwapIfPossible() {
-  TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionDrawAndSwap");
+DrawResult ProxyImpl::ScheduledActionSubmitCompositorFrameIfPossible() {
+  TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionSubmitCompositorFrame");
   DCHECK(IsImplThread());
 
   // SchedulerStateMachine::DidDrawIfPossibleCompleted isn't set up to
   // handle DRAW_ABORTED_CANT_DRAW.  Moreover, the scheduler should
   // never generate this call when it can't draw.
   DCHECK(layer_tree_host_impl_->CanDraw());
 
   bool forced_draw = false;
-  return DrawAndSwapInternal(forced_draw);
+  return SubmitCompositorFrameInternal(forced_draw);
 }
 
-DrawResult ProxyImpl::ScheduledActionDrawAndSwapForced() {
-  TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionDrawAndSwapForced");
+DrawResult ProxyImpl::ScheduledActionSubmitCompositorFrameForced() {
+  TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionSubmitCompositorFrameForced");
   DCHECK(IsImplThread());
   bool forced_draw = true;
-  return DrawAndSwapInternal(forced_draw);
+  return SubmitCompositorFrameInternal(forced_draw);
 }
 
 void ProxyImpl::ScheduledActionCommit() {
   TRACE_EVENT0("cc", "ProxyImpl::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(commit_completion_event_);
 
   layer_tree_host_impl_->BeginCommit();
   blocked_main_commit().layer_tree_host->FinishCommitOnImplThread(
@@ skipping 52 matching lines @@
   DCHECK(IsImplThread());
   DCHECK(layer_tree_host_impl_->compositor_frame_sink());
   layer_tree_host_impl_->compositor_frame_sink()->Invalidate();
 }
 
 void ProxyImpl::SendBeginMainFrameNotExpectedSoon() {
   DCHECK(IsImplThread());
   channel_impl_->BeginMainFrameNotExpectedSoon();
 }
 
-DrawResult ProxyImpl::DrawAndSwapInternal(bool forced_draw) {
-  TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
+DrawResult ProxyImpl::SubmitCompositorFrameInternal(bool forced_draw) {
+  TRACE_EVENT_SYNTHETIC_DELAY("cc.SubmitCompositorFrame");
 
   DCHECK(IsImplThread());
   DCHECK(layer_tree_host_impl_.get());
 
   base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
   if (layer_tree_host_impl_->pending_tree()) {
     bool update_lcd_text = false;
     layer_tree_host_impl_->pending_tree()->UpdateDrawProperties(
         update_lcd_text);
@@ skipping 16 matching lines @@
   DrawResult result;
   if (layer_tree_host_impl_->CanDraw()) {
     result = layer_tree_host_impl_->PrepareToDraw(&frame);
     draw_frame = forced_draw || result == DRAW_SUCCESS;
   } else {
     result = DRAW_ABORTED_CANT_DRAW;
   }
 
   if (draw_frame) {
     if (layer_tree_host_impl_->DrawLayers(&frame))
-      scheduler_->DidSwapBuffers();
+      scheduler_->DidSubmitCompositorFrame();
     result = DRAW_SUCCESS;
   } else {
     DCHECK_NE(DRAW_SUCCESS, result);
   }
 
   layer_tree_host_impl_->DidDrawAllLayers(frame);
 
   bool start_ready_animations = draw_frame;
   layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
@@ skipping 14 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