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/compositor_overlay_candidate_validator_android.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/android/child_process_launcher_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_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 content {
 
 namespace {
@@ skipping 140 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_;
 };
 
+#if defined(ENABLE_VULKAN)
+class VulkanOutputSurface : public cc::OutputSurface {
+ public:
+  VulkanOutputSurface(
+      scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider)
+      : OutputSurface(nullptr,
+                      nullptr,
+                      std::move(vulkan_context_provider),
+                      nullptr) {}
+
+  ~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_;
+
+  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;
 
 base::LazyInstance<cc::SurfaceManager> g_surface_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 int g_surface_id_namespace = 0;
 
 class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
  public:
   SingleThreadTaskGraphRunner() {
@@ skipping 36 matching lines @@
 std::unique_ptr<cc::SurfaceIdAllocator>
 CompositorImpl::CreateSurfaceIdAllocator() {
   std::unique_ptr<cc::SurfaceIdAllocator> allocator(
       new cc::SurfaceIdAllocator(++g_surface_id_namespace));
   cc::SurfaceManager* manager = GetSurfaceManager();
   DCHECK(manager);
   allocator->RegisterSurfaceIdNamespace(manager);
   return allocator;
 }
 
+// static
+scoped_refptr<cc::VulkanInProcessContextProvider>
+CompositorImpl::SharedVulkanContextProviderAndroid() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableVulkan)) {
+    scoped_refptr<cc::VulkanInProcessContextProvider>* context_provider =
+        g_shared_vulkan_context_provider_android_.Pointer();
+    if (*context_provider == NULL)
+      *context_provider = cc::VulkanInProcessContextProvider::Create();
+    return *context_provider;
+  }
+  return nullptr;
+}
+
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create()),
       surface_id_allocator_(CreateSurfaceIdAllocator()),
       resource_manager_(root_window),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
@@ skipping 210 matching lines @@
   RequestNewOutputSurface();
 }
 
 void CompositorImpl::CreateOutputSurface() {
   // We might have had a request from a LayerTreeHost that was then
   // hidden (and hidden means we don't have a native surface).
   // Also make sure we only handle this once.
   if (!output_surface_request_pending_ || !host_->visible())
     return;
 
-  // This is used for the browser compositor (offscreen) and for the display
-  // compositor (onscreen), so ask for capabilities needed by either one.
-  // The default framebuffer for an offscreen context is not used, so it does
-  // not need alpha, stencil, depth, antialiasing. The display compositor does
-  // not use these things either, except for alpha when it has a transparent
-  // background.
-  gpu::gles2::ContextCreationAttribHelper attributes;
-  attributes.alpha_size = -1;
-  attributes.stencil_size = 0;
-  attributes.depth_size = 0;
-  attributes.samples = 0;
-  attributes.sample_buffers = 0;
-  attributes.bind_generates_resource = false;
+  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)));
+    if (!vulkan_surface->Initialize(window_)) {
+      vulkan_surface->Destroy();
+      vulkan_surface.reset();
+    } else {
+      real_output_surface = std::move(vulkan_surface);
+    }
+  }
+#endif
 
-  if (has_transparent_background_) {
-    attributes.alpha_size = 8;
-  } else if (base::SysInfo::IsLowEndDevice()) {
-    // In this case we prefer to use RGB565 format instead of RGBA8888 if
-    // possible.
-    // TODO(danakj): GpuCommandBufferStub constructor checks for alpha == 0 in
-    // order to enable 565, but it should avoid using 565 when -1s are specified
-    // (IOW check that a <= 0 && rgb > 0 && rgb <= 565) then alpha should be -1.
-    attributes.alpha_size = 0;
-    attributes.red_size = 5;
-    attributes.green_size = 6;
-    attributes.blue_size = 5;
+  if (!real_output_surface) {
+    // This is used for the browser compositor (offscreen) and for the display
+    // compositor (onscreen), so ask for capabilities needed by either one.
+    // The default framebuffer for an offscreen context is not used, so it does
+    // not need alpha, stencil, depth, antialiasing. The display compositor does
+    // not use these things either, except for alpha when it has a transparent
+    // background.
+    gpu::gles2::ContextCreationAttribHelper attributes;
+    attributes.alpha_size = -1;
+    attributes.stencil_size = 0;
+    attributes.depth_size = 0;
+    attributes.samples = 0;
+    attributes.sample_buffers = 0;
+    attributes.bind_generates_resource = false;
+
+    if (has_transparent_background_) {
+      attributes.alpha_size = 8;
+    } else if (base::SysInfo::IsLowEndDevice()) {
+      // In this case we prefer to use RGB565 format instead of RGBA8888 if
+      // possible.
+      // TODO(danakj): GpuCommandBufferStub constructor checks for alpha == 0 in
+      // order to enable 565, but it should avoid using 565 when -1s are
+      // specified
+      // (IOW check that a <= 0 && rgb > 0 && rgb <= 565) then alpha should be
+      // -1.
+      attributes.alpha_size = 0;
+      attributes.red_size = 5;
+      attributes.green_size = 6;
+      attributes.blue_size = 5;
+    }
+
+    pending_swapbuffers_ = 0;
+
+    DCHECK(window_);
+    DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
+
+    BrowserGpuChannelHostFactory* factory =
+        BrowserGpuChannelHostFactory::instance();
+    // This channel might be lost (and even if it isn't right now, it might
+    // still get marked as lost from the IO thread, at any point in time
+    // really).
+    // But from here on just try and always lead to either
+    // DidInitializeOutputSurface() or DidFailToInitializeOutputSurface().
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
+        factory->GetGpuChannel());
+
+    GURL url("chrome://gpu/CompositorImpl::CreateOutputSurface");
+    constexpr bool automatic_flushes = false;
+
+    constexpr size_t kBytesPerPixel = 4;
+    const size_t full_screen_texture_size_in_bytes =
+        gfx::DeviceDisplayInfo().GetDisplayHeight() *
+        gfx::DeviceDisplayInfo().GetDisplayWidth() * kBytesPerPixel;
+
+    gpu::SharedMemoryLimits limits;
+    // This limit is meant to hold the contents of the display compositor
+    // drawing the scene. See discussion here:
+    // https://codereview.chromium.org/1900993002/diff/90001/content/browser/renderer_host/compositor_impl_android.cc?context=3&column_width=80&tab_spaces=8
+    limits.command_buffer_size = 64 * 1024;
+    // These limits are meant to hold the uploads for the browser UI without
+    // any excess space.
+    limits.start_transfer_buffer_size = 64 * 1024;
+    limits.min_transfer_buffer_size = 64 * 1024;
+    limits.max_transfer_buffer_size = full_screen_texture_size_in_bytes;
+    // Texture uploads may use mapped memory so give a reasonable limit for
+    // them.
+    limits.mapped_memory_reclaim_limit = full_screen_texture_size_in_bytes;
+
+    context_provider = new ContextProviderCommandBuffer(
+        std::move(gpu_channel_host), surface_handle_, url,
+        gfx::PreferIntegratedGpu, automatic_flushes, limits, attributes,
+        nullptr, command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
+    DCHECK(context_provider.get());
+
+    real_output_surface = base::WrapUnique(new OutputSurfaceWithoutParent(
+        this, context_provider,
+        base::Bind(&CompositorImpl::PopulateGpuCapabilities,
+                   base::Unretained(this)),
+        base::WrapUnique(new ExternalBeginFrameSource(this))));
   }
 
-  pending_swapbuffers_ = 0;
-
-  DCHECK(window_);
-  DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
-
-  BrowserGpuChannelHostFactory* factory =
-      BrowserGpuChannelHostFactory::instance();
-  // This channel might be lost (and even if it isn't right now, it might
-  // still get marked as lost from the IO thread, at any point in time really).
-  // But from here on just try and always lead to either
-  // DidInitializeOutputSurface() or DidFailToInitializeOutputSurface().
-  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(factory->GetGpuChannel());
-
-  GURL url("chrome://gpu/CompositorImpl::CreateOutputSurface");
-  constexpr bool automatic_flushes = false;
-
-  constexpr size_t kBytesPerPixel = 4;
-  const size_t full_screen_texture_size_in_bytes =
-      gfx::DeviceDisplayInfo().GetDisplayHeight() *
-      gfx::DeviceDisplayInfo().GetDisplayWidth() * kBytesPerPixel;
-
-  gpu::SharedMemoryLimits limits;
-  // This limit is meant to hold the contents of the display compositor
-  // drawing the scene. See discussion here:
-  // https://codereview.chromium.org/1900993002/diff/90001/content/browser/renderer_host/compositor_impl_android.cc?context=3&column_width=80&tab_spaces=8
-  limits.command_buffer_size = 64 * 1024;
-  // These limits are meant to hold the uploads for the browser UI without
-  // any excess space.
-  limits.start_transfer_buffer_size = 64 * 1024;
-  limits.min_transfer_buffer_size = 64 * 1024;
-  limits.max_transfer_buffer_size = full_screen_texture_size_in_bytes;
-  // 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(
-          std::move(gpu_channel_host), surface_handle_, url,
-          gfx::PreferIntegratedGpu, automatic_flushes, limits, attributes,
-          nullptr,
-          command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT));
-  DCHECK(context_provider.get());
-
-  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))));
-
   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(),
-                                          context_provider, nullptr));
+      vulkan_context_provider
+          ? new cc::SurfaceDisplayOutputSurface(
+                manager, surface_id_allocator_.get(),
+                static_cast<scoped_refptr<cc::VulkanContextProvider>>(
+                    vulkan_context_provider))
+          : new cc::SurfaceDisplayOutputSurface(manager,
+                                                surface_id_allocator_.get(),
+                                                context_provider, nullptr));
 
   display_client_->set_surface_output_surface(surface_output_surface.get());
   surface_output_surface->set_display_client(display_client_.get());
   display_client_->display()->Resize(size_);
   host_->SetOutputSurface(std::move(surface_output_surface));
 }
 
 void CompositorImpl::PopulateGpuCapabilities(
     gpu::Capabilities gpu_capabilities) {
   gpu_capabilities_ = gpu_capabilities;
@@ skipping 73 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content