cc: Rename SwapBuffers on CompositorFrameSink to SubmitCompositorFrame

content/renderer/android/synchronous_compositor_proxy.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 "content/renderer/android/synchronous_compositor_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "cc/ipc/cc_param_traits.h"
@@ skipping 178 matching lines @@
     // Did not swap.
     if (!reply_message) {
       SendDemandDrawHwReplyAsync(cc::CompositorFrame(), 0u);
     } else {
       SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message);
     }
     inside_receive_ = false;
   }
 }
 
-void SynchronousCompositorProxy::SwapBuffersHwAsync(
+void SynchronousCompositorProxy::SubmitCompositorFrameHwAsync(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_async_);
   SendDemandDrawHwReplyAsync(std::move(frame), compositor_frame_sink_id);
   inside_receive_ = false;
 }
 
-void SynchronousCompositorProxy::SwapBuffersHw(
+void SynchronousCompositorProxy::SubmitCompositorFrameHw(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_);
   SendDemandDrawHwReply(std::move(frame), compositor_frame_sink_id,
                         hardware_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReplyAsync(
@@ skipping 93 matching lines @@
   SkBitmap bitmap;
   if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride))
     return;
   SkCanvas canvas(bitmap);
   canvas.concat(params.transform.matrix());
   canvas.clipRect(gfx::RectToSkRect(params.clip));
 
   compositor_frame_sink_->DemandDrawSw(&canvas);
 }
 
-void SynchronousCompositorProxy::SwapBuffersSw(cc::CompositorFrame frame) {
+void SynchronousCompositorProxy::SubmitCompositorFrameSw(
+    cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(software_draw_reply_);
   SendDemandDrawSwReply(true, std::move(frame), software_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawSwReply(
     bool success,
     cc::CompositorFrame frame,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
   SyncCompositorMsg_DemandDrawSw::WriteReplyParams(
       reply_message, success, common_renderer_params, frame);
   Send(reply_message);
 }
 
-void SynchronousCompositorProxy::SwapBuffers(uint32_t compositor_frame_sink_id,
-                                             cc::CompositorFrame frame) {
+void SynchronousCompositorProxy::SubmitCompositorFrame(
+    uint32_t compositor_frame_sink_id,
+    cc::CompositorFrame frame) {
   // Verify that exactly one of these is true.
   DCHECK(hardware_draw_reply_async_ || hardware_draw_reply_ ||
          software_draw_reply_);
   DCHECK(!((hardware_draw_reply_ && software_draw_reply_) ||
            (hardware_draw_reply_ && hardware_draw_reply_async_) ||
            (software_draw_reply_ && hardware_draw_reply_async_)));
   if (hardware_draw_reply_async_) {
-    SwapBuffersHwAsync(compositor_frame_sink_id, std::move(frame));
+    SubmitCompositorFrameHwAsync(compositor_frame_sink_id, std::move(frame));
   } else if (hardware_draw_reply_) {
-    SwapBuffersHw(compositor_frame_sink_id, std::move(frame));
+    SubmitCompositorFrameHw(compositor_frame_sink_id, std::move(frame));
   } else if (software_draw_reply_) {
-    SwapBuffersSw(std::move(frame));
+    SubmitCompositorFrameSw(std::move(frame));
   }
 }
 
 void SynchronousCompositorProxy::OnComputeScroll(
     base::TimeTicks animation_time) {
   if (need_animate_scroll_) {
     need_animate_scroll_ = false;
     input_handler_proxy_->SynchronouslyAnimate(animation_time);
   }
 }
@@ skipping 10 matching lines @@
 
 void SynchronousCompositorProxy::SetScroll(
     const gfx::ScrollOffset& new_total_scroll_offset) {
   if (total_scroll_offset_ == new_total_scroll_offset)
     return;
   total_scroll_offset_ = new_total_scroll_offset;
   input_handler_proxy_->SynchronouslySetRootScrollOffset(total_scroll_offset_);
 }
 
 }  // namespace content