Add support for OutputSurface for Vulkan 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 17 matching lines @@
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
+#include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/onscreen_display_client.h"
 #include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #include "content/browser/compositor/browser_compositor_overlay_candidate_validator_android.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu_process_launch_causes.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/public/browser/android/compositor.h"
 #include "content/public/browser/android/compositor_client.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
+#include "gpu/vulkan/vulkan_surface.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "ui/android/window_android.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/swap_result.h"
 
+namespace gpu {
+class VulkanSurface;
+}
+
 namespace content {
 
 namespace {
 
 const unsigned int kMaxDisplaySwapBuffers = 1U;
 
 class ExternalBeginFrameSource : public cc::BeginFrameSourceBase,
                                  public CompositorImpl::VSyncObserver {
  public:
   ExternalBeginFrameSource(CompositorImpl* compositor)
@@ skipping 132 matching lines @@
  private:
   CompositorImpl* compositor_;
   base::Callback<void(gpu::Capabilities)> populate_gpu_capabilities_callback_;
   base::CancelableCallback<void(const std::vector<ui::LatencyInfo>&,
                                 gfx::SwapResult)>
       swap_buffers_completion_callback_;
   std::unique_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator_;
   std::unique_ptr<ExternalBeginFrameSource> begin_frame_source_;
 };
 
+class VulkanOutputSurface : public cc::OutputSurface {

[piman, 2016/04/28 21:29:40]

I think this whole class needs to be inside #if defined(ENABLE_VULKAN), because
otherwise you won't have an implementation for VulkanSurface.

[sohanjg, 2016/04/29 11:49:58]

Done.

+ public:
+  VulkanOutputSurface(
+      const scoped_refptr<cc::VulkanContextProvider>& vulkan_context_provider)

[piman, 2016/04/28 21:29:40]

nit: scoped_refptr<cc::VulkanContextProvider> (not const scoped_refptr<>&), per
style guide.

[sohanjg, 2016/04/29 11:49:58]

Done.

+      : OutputSurface(nullptr, nullptr, vulkan_context_provider, nullptr) {}

[piman, 2016/04/28 21:29:40]

nit: std::move(vulkan_context_provider)

[sohanjg, 2016/04/29 11:49:58]

Done.

+
+  ~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;
+  }
+
+  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_;

[piman, 2016/04/28 21:29:40]

nit: DISALLOW_COPY_AND_ASSIGN()

[sohanjg, 2016/04/29 11:49:58]

Done.

+};
+
 static bool g_initialized = false;
 
 base::LazyInstance<cc::SurfaceManager> g_surface_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 int g_surface_id_namespace = 0;
 
 class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
  public:
   SingleThreadTaskGraphRunner() {
@@ skipping 338 matching lines @@
   // Texture uploads may use mapped memory so give a reasonable limit for them.
   limits.mapped_memory_reclaim_limit = full_screen_texture_size_in_bytes;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider(
       new ContextProviderCommandBuffer(
           base::WrapUnique(new WebGraphicsContext3DCommandBufferImpl(
               surface_handle, url, gpu_channel_host.get(), attributes,
               gfx::PreferIntegratedGpu, share_resources, automatic_flushes,
               nullptr)),
           limits, DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT));
   DCHECK(context_provider.get());

[piman, 2016/04/28 21:29:40]

All this code (from l.560 to here) should only execute when we don't use Vulkan.
We will not use ContextProviderCommandBuffer when using Vulkan.
Maybe it should move to the if (!real_output_surface) block below?

[sohanjg, 2016/04/29 11:49:58]

Done.

 
-  std::unique_ptr<cc::OutputSurface> real_output_surface(
-      new OutputSurfaceWithoutParent(
-          this, context_provider,
-          base::Bind(&CompositorImpl::PopulateGpuCapabilities,
-                     base::Unretained(this)),
-          base::WrapUnique(new ExternalBeginFrameSource(this))));
+  scoped_refptr<cc::VulkanInProcessContextProvider> vulkan_context_provider =
+      cc::VulkanInProcessContextProvider::Create();

[piman, 2016/04/28 21:29:40]

I think we would want to share this across multiple CompositorImpl (similar to
GpuProcessTransportFactory::SharedVulkanContextProvider).

Also, we added a command-line flag (kEnableVulkan), we should use it to decide
whether or not to try to talk to Vulkan.

[sohanjg, 2016/04/29 11:49:58]

Done.

+  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(vulkan_context_provider));

[piman, 2016/04/28 21:29:40]

nit: std::move(vulkan_context_provider)

[sohanjg, 2016/04/29 11:49:58]

Done.

+    if (!vulkan_surface->Initialize(window_)) {
+      vulkan_surface->Destroy();
+      vulkan_surface.reset();
+    } else {
+      real_output_surface = std::move(vulkan_surface);
+    }
+  }
+#endif
+
+  if (!real_output_surface) {
+    real_output_surface = base::WrapUnique(new OutputSurfaceWithoutParent(
+        this, context_provider,
+        base::Bind(&CompositorImpl::PopulateGpuCapabilities,
+                   base::Unretained(this)),
+        base::WrapUnique(new ExternalBeginFrameSource(this))));
+  }
 
   cc::SurfaceManager* manager = GetSurfaceManager();
   display_client_.reset(new cc::OnscreenDisplayClient(
       std::move(real_output_surface), manager,
       HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
       host_->settings().renderer_settings, base::ThreadTaskRunnerHandle::Get(),
       surface_id_allocator_->id_namespace()));
   std::unique_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
       new cc::SurfaceDisplayOutputSurface(manager, surface_id_allocator_.get(),
@@ skipping 84 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content