cc: Rename SwapBuffers on CompositorFrameSink to SubmitCompositorFrame

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 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 "content/renderer/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 193 matching lines @@
   display_ = nullptr;
   surface_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
 }
 
 static void NoOpDrawCallback() {}
 
-void SynchronousCompositorFrameSink::SwapBuffers(cc::CompositorFrame frame) {
+void SynchronousCompositorFrameSink::SubmitCompositorFrame(
+    cc::CompositorFrame frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
 
   if (fallback_tick_running_) {
     DCHECK(frame.delegated_frame_data->resource_list.empty());
     cc::ReturnedResourceArray return_resources;
     ReturnResources(return_resources);
-    did_swap_ = true;
+    did_submit_frame_ = true;
     return;
   }
 
-  cc::CompositorFrame swap_frame;
+  cc::CompositorFrame submit_frame;
 
   if (in_software_draw_) {
     // The frame we send to the client is actually just the metadata. Preserve
     // the |frame| for the software path below.
-    swap_frame.metadata = frame.metadata.Clone();
+    submit_frame.metadata = frame.metadata.Clone();
 
     if (root_local_frame_id_.is_null()) {
       root_local_frame_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(root_local_frame_id_);
       child_local_frame_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(child_local_frame_id_);
     }
 
     display_->SetSurfaceId(cc::SurfaceId(kFrameSinkId, root_local_frame_id_),
                            frame.metadata.device_scale_factor);
@@ skipping 48 matching lines @@
 
     surface_factory_->SubmitCompositorFrame(
         child_local_frame_id_, std::move(frame), base::Bind(&NoOpDrawCallback));
     surface_factory_->SubmitCompositorFrame(root_local_frame_id_,
                                             std::move(embed_frame),
                                             base::Bind(&NoOpDrawCallback));
     display_->DrawAndSwap();
   } else {
     // For hardware draws we send the whole frame to the client so it can draw
     // the content in it.
-    swap_frame = std::move(frame);
+    submit_frame = std::move(frame);
   }
 
-  sync_client_->SwapBuffers(compositor_frame_sink_id_, std::move(swap_frame));
+  sync_client_->SubmitCompositorFrame(compositor_frame_sink_id_,
+                                      std::move(submit_frame));
   DeliverMessages();
-  did_swap_ = true;
+  did_submit_frame_ = true;
 }
 
 void SynchronousCompositorFrameSink::CancelFallbackTick() {
   fallback_tick_.Cancel();
   fallback_tick_pending_ = false;
 }
 
 void SynchronousCompositorFrameSink::FallbackTickFired() {
   DCHECK(CalledOnValidThread());
   TRACE_EVENT0("renderer", "SynchronousCompositorFrameSink::FallbackTickFired");
@@ skipping 55 matching lines @@
   // save it for later.
   sw_viewport_for_current_draw_ = viewport;
 
   base::AutoReset<bool> set_in_software_draw(&in_software_draw_, true);
   InvokeComposite(transform, viewport);
 }
 
 void SynchronousCompositorFrameSink::InvokeComposite(
     const gfx::Transform& transform,
     const gfx::Rect& viewport) {
-  did_swap_ = false;
+  did_submit_frame_ = false;
   // Adjust transform so that the layer compositor draws the |viewport| rect
   // at its origin. The offset of the |viewport| we pass to the layer compositor
   // is ignored for drawing, so its okay to not match the transform.
   // TODO(danakj): Why do we pass a viewport origin and then not really use it
   // (only for comparing to the viewport passed in
   // SetExternalTilePriorityConstraints), surely this could be more clear?
   gfx::Transform adjusted_transform = transform;
   adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
   client_->OnDraw(adjusted_transform, viewport, in_software_draw_);
 
-  if (did_swap_) {
+  if (did_submit_frame_) {
     // This must happen after unwinding the stack and leaving the compositor.
     // Usually it is a separate task but we just defer it until OnDraw completes
     // instead.
-    client_->DidSwapBuffersComplete();
+    client_->DidReceiveCompositorFrameAck();
   }
 }
 
 void SynchronousCompositorFrameSink::OnReclaimResources(
     uint32_t compositor_frame_sink_id,
     const cc::ReturnedResourceArray& resources) {
   // Ignore message if it's a stale one coming from a different output surface
   // (e.g. after a lost context).
   if (compositor_frame_sink_id != compositor_frame_sink_id_)
     return;
@@ skipping 54 matching lines @@
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content