cc: Rename SwapBuffers on CompositorFrameSink to SubmitCompositorFrame

cc/blimp/layer_tree_host_remote.cc

 // Copyright 2016 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/blimp/layer_tree_host_remote.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
@@ skipping 396 matching lines @@
   MainFrameComplete();
 
   // We can not wait for updates dispatched from the client about the state of
   // drawing or swaps for frames sent. Since these calls can be used by the
   // LayerTreeHostClient to throttle further frame updates, so dispatch them
   // right after the update is processed by the bridge.
   // TODO(khushalsagar): We can not really know what these callbacks end up
   // being used for. Consider migrating clients to understand/cope with the fact
   // that there is no actual compositing happening here.
   task_runner_provider_->MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&LayerTreeHostRemote::DispatchDrawAndSwapCallbacks,
-                            weak_factory_.GetWeakPtr()));
+      FROM_HERE,
+      base::Bind(&LayerTreeHostRemote::DispatchDrawAndSubmitCallbacks,
+                 weak_factory_.GetWeakPtr()));
 }
 
 bool LayerTreeHostRemote::ApplyScrollAndScaleUpdateFromClient(
     const ScrollOffsetMap& client_scroll_map,
     float client_page_scale) {
   DCHECK(!synchronizing_client_updates_);
 
   base::AutoReset<bool> synchronizing_updates(&synchronizing_client_updates_,
                                               true);
   bool layer_sync_successful = true;
@@ skipping 35 matching lines @@
   DCHECK_EQ(current_pipeline_stage_, FramePipelineStage::COMMIT);
 
   current_pipeline_stage_ = FramePipelineStage::NONE;
   max_pipeline_stage_for_current_frame_ = FramePipelineStage::NONE;
   source_frame_number_++;
 
   client_->DidCommit();
   client_->DidBeginMainFrame();
 }
 
-void LayerTreeHostRemote::DispatchDrawAndSwapCallbacks() {
+void LayerTreeHostRemote::DispatchDrawAndSubmitCallbacks() {
   client_->DidCommitAndDrawFrame();
-  client_->DidCompleteSwapBuffers();
+  client_->DidReceiveCompositorFrameAck();
 }
 
 void LayerTreeHostRemote::SetTaskRunnerProviderForTesting(
     std::unique_ptr<TaskRunnerProvider> task_runner_provider) {
   task_runner_provider_ = std::move(task_runner_provider);
 }
 
 void LayerTreeHostRemote::SerializeCurrentState(
     proto::LayerTreeHost* layer_tree_host_proto) {
   // We need to serialize only the inputs received from the embedder.
   const bool inputs_only = true;
 
   // Serialize the LayerTree.
   layer_tree_->ToProtobuf(layer_tree_host_proto->mutable_layer_tree(),
                           inputs_only);
 
   // Serialize the dirty layers.
   for (auto* layer : layer_tree_->LayersThatShouldPushProperties())
     layer->ToLayerPropertiesProto(
         layer_tree_host_proto->mutable_layer_updates(), inputs_only);
   layer_tree_->LayersThatShouldPushProperties().clear();
 
   std::vector<PictureData> pictures =
       engine_picture_cache_->CalculateCacheUpdateAndFlush();
   proto::PictureDataVectorToSkPicturesProto(
       pictures, layer_tree_host_proto->mutable_pictures());
 }
 
 }  // namespace cc