android: Rename SwapBuffers to SwapFrames

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 316 matching lines @@
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : frame_sink_id_(
           ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()),
       resource_manager_(root_window),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
       root_window_(root_window),
       needs_animate_(false),
-      pending_swapbuffers_(0U),
+      pending_frames_(0U),
       num_successive_context_creation_failures_(0),
       compositor_frame_sink_request_pending_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->RegisterFrameSinkId(frame_sink_id_);
   DCHECK(client);
   DCHECK(root_window);
   DCHECK(root_window->GetLayer() == nullptr);
   root_window->SetLayer(cc::Layer::Create());
@@ skipping 112 matching lines @@
 
     // Make a best effort to try to complete pending readbacks.
     // TODO(crbug.com/637035): Consider doing this in a better way,
     // ideally with the guarantee of readbacks completing.
     if (display_.get() && HavePendingReadbacks())
       display_->ForceImmediateDrawAndSwapIfPossible();
 
     host_->SetVisible(false);
     host_->ReleaseCompositorFrameSink();
     has_compositor_frame_sink_ = false;
-    pending_swapbuffers_ = 0;
+    pending_frames_ = 0;
     display_.reset();
   } else {
     host_->SetVisible(true);
     if (compositor_frame_sink_request_pending_)
       HandlePendingCompositorFrameSinkRequest();
   }
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
@@ skipping 157 matching lines @@
       break;
   }
 }
 
 void CompositorImpl::InitializeDisplay(
     std::unique_ptr<cc::OutputSurface> display_output_surface,
     scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
     scoped_refptr<cc::ContextProvider> context_provider) {
   DCHECK(compositor_frame_sink_request_pending_);
 
-  pending_swapbuffers_ = 0;
+  pending_frames_ = 0;
   num_successive_context_creation_failures_ = 0;
 
   if (context_provider) {
     gpu_capabilities_ = context_provider->ContextCapabilities();
   } else {
     // TODO(danakj): Populate gpu_capabilities_ for VulkanContextProvider.
   }
 
   cc::SurfaceManager* manager =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
@@ skipping 34 matching lines @@
   TRACE_EVENT0("compositor", "CompositorImpl::DeleteUIResource");
   host_->GetUIResourceManager()->DeleteUIResource(resource_id);
 }
 
 bool CompositorImpl::SupportsETC1NonPowerOfTwo() const {
   return gpu_capabilities_.texture_format_etc1_npot;
 }
 
 void CompositorImpl::DidSubmitCompositorFrame() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidSubmitCompositorFrame");
-  pending_swapbuffers_++;
+  pending_frames_++;
 }
 
 void CompositorImpl::DidReceiveCompositorFrameAck() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidReceiveCompositorFrameAck");
-  DCHECK_GT(pending_swapbuffers_, 0U);
-  pending_swapbuffers_--;
-  client_->OnSwapBuffersCompleted(pending_swapbuffers_);
+  DCHECK_GT(pending_frames_, 0U);
+  pending_frames_--;
+  client_->DidSwapFrame(pending_frames_);
 }
 
 void CompositorImpl::DidLoseCompositorFrameSink() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidLoseCompositorFrameSink");
   has_compositor_frame_sink_ = false;
-  client_->OnSwapBuffersCompleted(0);
+  client_->DidSwapFrame(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   readback_layer_tree_->AddChild(layer);
 }
 
@@ skipping 35 matching lines @@
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->UnregisterFrameSinkHierarchy(frame_sink_id_, frame_sink_id);
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content