Setup BFS for Vulkan Output Surface on Android.

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>
 
@@ skipping 217 matching lines @@
       const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac)>
           swap_buffers_completion_callback_;
   std::unique_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator_;
   std::unique_ptr<ExternalBeginFrameSource> begin_frame_source_;
 };
 
 #if defined(ENABLE_VULKAN)
 class VulkanOutputSurface : public cc::OutputSurface {
  public:
   VulkanOutputSurface(
-      scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider)
+      scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
+      std::unique_ptr<ExternalBeginFrameSource> begin_frame_source)
       : OutputSurface(nullptr,
                       nullptr,
                       std::move(vulkan_context_provider),
-                      nullptr) {}
+                      nullptr),
+        begin_frame_source_(std::move(begin_frame_source)) {}
 
   ~VulkanOutputSurface() override { Destroy(); }
 
   bool Initialize(gfx::AcceleratedWidget widget) {
     DCHECK(!surface_);
     std::unique_ptr<gpu::VulkanSurface> surface(
         gpu::VulkanSurface::CreateViewSurface(widget));
     if (!surface->Initialize(vulkan_context_provider()->GetDeviceQueue(),
                              gpu::VulkanSurface::DEFAULT_SURFACE_FORMAT)) {
       return false;
     }
     surface_ = std::move(surface);
 
     return true;
   }
 
+  bool BindToClient(cc::OutputSurfaceClient* client) override {
+    if (!OutputSurface::BindToClient(client))
+      return false;
+    client->SetBeginFrameSource(begin_frame_source_.get());
+    return true;
+  }
+
   void SwapBuffers(cc::CompositorFrame* frame) override {
     surface_->SwapBuffers();
     PostSwapBuffersComplete();
     client_->DidSwapBuffers();
   }
 
   void Destroy() {
     if (surface_) {
       surface_->Destroy();
       surface_.reset();
     }
   }
 
   void OnSwapBuffersCompleted(const std::vector<ui::LatencyInfo>& latency_info,
                               gfx::SwapResult result) {
     RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
     OutputSurface::OnSwapBuffersComplete();
   }
 
  private:
   std::unique_ptr<gpu::VulkanSurface> surface_;
+  std::unique_ptr<ExternalBeginFrameSource> begin_frame_source_;
 
   DISALLOW_COPY_AND_ASSIGN(VulkanOutputSurface);
 };
 #endif
 
 base::LazyInstance<scoped_refptr<cc::VulkanInProcessContextProvider>>
     g_shared_vulkan_context_provider_android_ = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_initialized = false;
 
@@ skipping 295 matching lines @@
   if (!output_surface_request_pending_ || !host_->visible())
     return;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   scoped_refptr<cc::VulkanInProcessContextProvider> vulkan_context_provider =
       SharedVulkanContextProviderAndroid();
   std::unique_ptr<cc::OutputSurface> real_output_surface;
 #if defined(ENABLE_VULKAN)
   std::unique_ptr<VulkanOutputSurface> vulkan_surface;
   if (vulkan_context_provider) {
-    vulkan_surface.reset(
-        new VulkanOutputSurface(std::move(vulkan_context_provider)));
+    vulkan_surface.reset(new VulkanOutputSurface(
+        std::move(vulkan_context_provider),
+        base::WrapUnique(new ExternalBeginFrameSource(this))));
     if (!vulkan_surface->Initialize(window_)) {
       vulkan_surface->Destroy();
       vulkan_surface.reset();
     } else {
       real_output_surface = std::move(vulkan_surface);
     }
   }
 #endif
 
   if (!real_output_surface) {
@@ skipping 180 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content