gpu/vulkan/win32/vulkan_surface_win32.cc - chromium/src.git - Git at Google

 // Copyright 2020 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "gpu/vulkan/win32/vulkan_surface_win32.h"

 #include <windows.h>

 #include "base/functional/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
 #include "ui/gfx/win/window_impl.h"

 namespace gpu {

 namespace {

 // It is set by WindowThread ctor, and cleared by WindowThread dtor.
 VulkanSurfaceWin32::WindowThread* g_thread = nullptr;

 // It is set by HiddenToplevelWindow ctor, and cleared by HiddenToplevelWindow
 // dtor.
 class HiddenToplevelWindow* g_initial_parent_window = nullptr;

 class HiddenToplevelWindow : public gfx::WindowImpl,
                              public base::RefCounted<HiddenToplevelWindow> {
  public:
   HiddenToplevelWindow() : gfx::WindowImpl("VulkanHiddenToplevelWindow") {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(!g_initial_parent_window);
     set_initial_class_style(CS_OWNDC);
     set_window_style(WS_POPUP | WS_DISABLED);
     Init(GetDesktopWindow(), gfx::Rect());
     g_initial_parent_window = this;
   }

   HiddenToplevelWindow(const HiddenToplevelWindow&) = delete;
   HiddenToplevelWindow& operator=(const HiddenToplevelWindow&) = delete;

  private:
   friend class base::RefCounted<HiddenToplevelWindow>;

   // gfx::WindowImpl:
   BOOL ProcessWindowMessage(HWND window,
                             UINT message,
                             WPARAM w_param,
                             LPARAM l_param,
                             LRESULT& result,
                             DWORD msg_map_id) override {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     if (message == WM_CLOSE) {
       // Prevent closing the window, since external apps may get a handle to
       // this window and attempt to close it.
       result = 0;
       return true;
     }
     return false;
   }

   ~HiddenToplevelWindow() override {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK_EQ(g_initial_parent_window, this);
     g_initial_parent_window = nullptr;
   }

   THREAD_CHECKER(thread_checker_);
 };

 class ChildWindow : public gfx::WindowImpl {
  public:
   explicit ChildWindow(HWND parent_window)
       : gfx::WindowImpl("VulkanHiddenToplevelWindow") {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

     // If there is no other ChildWindow instance, |g_initial_parent_window| will
     // be nullptr, and then we need to create one. If |g_initial_parent_window|
     // is not nullptr, so |g_initial_parent_window| will not be destroyed until
     // this ChildWindow is destroyed.
     initial_parent_window_ = g_initial_parent_window;
     if (!initial_parent_window_)
       initial_parent_window_ = base::MakeRefCounted<HiddenToplevelWindow>();

     set_initial_class_style(CS_OWNDC);
     set_window_style(WS_VISIBLE | WS_CHILD | WS_DISABLED);
     RECT window_rect;
     if (!GetClientRect(parent_window, &window_rect))
       PLOG(DFATAL) << "GetClientRect() failed.";
     gfx::Rect bounds(window_rect);
     bounds.set_origin(gfx::Point(0, 0));
     Init(initial_parent_window_->hwnd(), bounds);
   }

   ~ChildWindow() override { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); }

   ChildWindow(const ChildWindow&) = delete;
   ChildWindow& operator=(const ChildWindow&) = delete;

  private:
   // gfx::WindowImpl:
   BOOL ProcessWindowMessage(HWND window,
                             UINT message,
                             WPARAM w_param,
                             LPARAM l_param,
                             LRESULT& result,
                             DWORD msg_map_id) override {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     switch (message) {
       case WM_ERASEBKGND:
         // Prevent windows from erasing the background.
         return true;
       case WM_PAINT:
         // Do not paint anything.
         PAINTSTRUCT paint;
         if (BeginPaint(window, &paint))
           EndPaint(window, &paint);
         return false;
       default:
         return false;
     }
   }

   // A temporary parent window for this child window, it will be reparented
   // by browser soon. All child windows share one initial parent window.
   // The initial parent window will be destroyed with the last child window.
   scoped_refptr<HiddenToplevelWindow> initial_parent_window_;

   THREAD_CHECKER(thread_checker_);
 };

 void CreateChildWindow(HWND parent_window,
                        std::unique_ptr<ChildWindow>* window,
                        base::WaitableEvent* event) {
   *window = std::make_unique<ChildWindow>(parent_window);
   event->Signal();
 }

 }  // namespace

 class VulkanSurfaceWin32::WindowThread : public base::Thread,
                                          public base::RefCounted<WindowThread> {
  public:
   WindowThread() : base::Thread("VulkanWindowThread") {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(!g_thread);
     g_thread = this;
     base::Thread::Options options(base::MessagePumpType::UI, 0);
     StartWithOptions(std::move(options));
   }

   WindowThread(const WindowThread&) = delete;
   WindowThread& operator=(const WindowThread&) = delete;

  private:
   friend class base::RefCounted<WindowThread>;

   ~WindowThread() override {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK_EQ(g_thread, this);
     Stop();
     g_thread = nullptr;
   }

   THREAD_CHECKER(thread_checker_);
 };

 // static
 std::unique_ptr<VulkanSurfaceWin32> VulkanSurfaceWin32::Create(
     VkInstance vk_instance,
     HWND parent_window) {
   scoped_refptr<WindowThread> thread = g_thread;
   if (!thread) {
     // If there is no other VulkanSurfaceWin32, g_thread will be nullptr, and
     // we need to create a thread for running child window message loop.
     // Otherwise keep a ref of g_thread, so it will not be destroyed until the
     // this VulkanSurfaceWin32 is destroyed.
     thread = base::MakeRefCounted<WindowThread>();
     g_thread = thread.get();
   }

   // vkCreateSwapChainKHR() fails in sandbox with a window which is created by
   // other process with NVIDIA driver. Workaround the problem by creating a
   // child window and use it to create vulkan surface.
   // TODO(penghuang): Only apply this workaround with NVIDIA GPU?
   // https://crbug.com/1068742
   std::unique_ptr<ChildWindow> window;
   base::WaitableEvent event;
   thread->task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&CreateChildWindow, parent_window, &window, &event));
   event.Wait();

   VkSurfaceKHR surface;
   VkWin32SurfaceCreateInfoKHR surface_create_info = {
       .sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
       .hinstance = reinterpret_cast<HINSTANCE>(
           GetWindowLongPtr(window->hwnd(), GWLP_HINSTANCE)),
       .hwnd = window->hwnd(),
   };
   VkResult result = vkCreateWin32SurfaceKHR(vk_instance, &surface_create_info,
                                             nullptr, &surface);
   if (VK_SUCCESS != result) {
     LOG(DFATAL) << "vkCreatWin32SurfaceKHR() failed: " << result;
     return nullptr;
   }
   return std::make_unique<VulkanSurfaceWin32>(
       base::PassKey<VulkanSurfaceWin32>(), vk_instance, surface,
       std::move(thread), std::move(window));
 }

 VulkanSurfaceWin32::VulkanSurfaceWin32(
     base::PassKey<VulkanSurfaceWin32> pass_key,
     VkInstance vk_instance,
     VkSurfaceKHR vk_surface,
     scoped_refptr<WindowThread> thread,
     std::unique_ptr<gfx::WindowImpl> window)
     : VulkanSurface(vk_instance, window->hwnd(), vk_surface),
       thread_(std::move(thread)),
       window_(std::move(window)) {}

 VulkanSurfaceWin32::~VulkanSurfaceWin32() {
   thread_->task_runner()->DeleteSoon(FROM_HERE, std::move(window_));
 }

 bool VulkanSurfaceWin32::Reshape(const gfx::Size& size,
                                  gfx::OverlayTransform pre_transform) {
   DCHECK_EQ(pre_transform, gfx::OVERLAY_TRANSFORM_NONE);
   constexpr auto kFlags = SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS |
                           SWP_NOOWNERZORDER | SWP_NOZORDER;
   if (!SetWindowPos(window_->hwnd(), nullptr, 0, 0, size.width(), size.height(),
                     kFlags)) {
     PLOG(DFATAL) << "SetWindowPos() failed";
     return false;
   }
   return VulkanSurface::Reshape(size, pre_transform);
 }

 }  // namespace gpu
	// Copyright 2020 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "gpu/vulkan/win32/vulkan_surface_win32.h"

	#include <windows.h>

	#include "base/functional/bind.h"
	#include "base/logging.h"
	#include "base/memory/ref_counted.h"
	#include "base/synchronization/waitable_event.h"
	#include "base/threading/thread.h"
	#include "base/threading/thread_checker.h"
	#include "gpu/vulkan/vulkan_function_pointers.h"
	#include "ui/gfx/win/window_impl.h"

	namespace gpu {

	namespace {

	// It is set by WindowThread ctor, and cleared by WindowThread dtor.
	VulkanSurfaceWin32::WindowThread* g_thread = nullptr;

	// It is set by HiddenToplevelWindow ctor, and cleared by HiddenToplevelWindow
	// dtor.
	class HiddenToplevelWindow* g_initial_parent_window = nullptr;

	class HiddenToplevelWindow : public gfx::WindowImpl,
	public base::RefCounted<HiddenToplevelWindow> {
	public:
	HiddenToplevelWindow() : gfx::WindowImpl("VulkanHiddenToplevelWindow") {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
	DCHECK(!g_initial_parent_window);
	set_initial_class_style(CS_OWNDC);
	set_window_style(WS_POPUP \| WS_DISABLED);
	Init(GetDesktopWindow(), gfx::Rect());
	g_initial_parent_window = this;
	}

	HiddenToplevelWindow(const HiddenToplevelWindow&) = delete;
	HiddenToplevelWindow& operator=(const HiddenToplevelWindow&) = delete;

	private:
	friend class base::RefCounted<HiddenToplevelWindow>;

	// gfx::WindowImpl:
	BOOL ProcessWindowMessage(HWND window,
	UINT message,
	WPARAM w_param,
	LPARAM l_param,
	LRESULT& result,
	DWORD msg_map_id) override {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
	if (message == WM_CLOSE) {
	// Prevent closing the window, since external apps may get a handle to
	// this window and attempt to close it.
	result = 0;
	return true;
	}
	return false;
	}

	~HiddenToplevelWindow() override {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
	DCHECK_EQ(g_initial_parent_window, this);
	g_initial_parent_window = nullptr;
	}

	THREAD_CHECKER(thread_checker_);
	};

	class ChildWindow : public gfx::WindowImpl {
	public:
	explicit ChildWindow(HWND parent_window)
	: gfx::WindowImpl("VulkanHiddenToplevelWindow") {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

	// If there is no other ChildWindow instance, \|g_initial_parent_window\| will
	// be nullptr, and then we need to create one. If \|g_initial_parent_window\|
	// is not nullptr, so \|g_initial_parent_window\| will not be destroyed until
	// this ChildWindow is destroyed.
	initial_parent_window_ = g_initial_parent_window;
	if (!initial_parent_window_)
	initial_parent_window_ = base::MakeRefCounted<HiddenToplevelWindow>();

	set_initial_class_style(CS_OWNDC);
	set_window_style(WS_VISIBLE \| WS_CHILD \| WS_DISABLED);
	RECT window_rect;
	if (!GetClientRect(parent_window, &window_rect))
	PLOG(DFATAL) << "GetClientRect() failed.";
	gfx::Rect bounds(window_rect);
	bounds.set_origin(gfx::Point(0, 0));
	Init(initial_parent_window_->hwnd(), bounds);
	}

	~ChildWindow() override { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); }

	ChildWindow(const ChildWindow&) = delete;
	ChildWindow& operator=(const ChildWindow&) = delete;

	private:
	// gfx::WindowImpl:
	BOOL ProcessWindowMessage(HWND window,
	UINT message,
	WPARAM w_param,
	LPARAM l_param,
	LRESULT& result,
	DWORD msg_map_id) override {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
	switch (message) {
	case WM_ERASEBKGND:
	// Prevent windows from erasing the background.
	return true;
	case WM_PAINT:
	// Do not paint anything.
	PAINTSTRUCT paint;
	if (BeginPaint(window, &paint))
	EndPaint(window, &paint);
	return false;
	default:
	return false;
	}
	}

	// A temporary parent window for this child window, it will be reparented
	// by browser soon. All child windows share one initial parent window.
	// The initial parent window will be destroyed with the last child window.
	scoped_refptr<HiddenToplevelWindow> initial_parent_window_;

	THREAD_CHECKER(thread_checker_);
	};

	void CreateChildWindow(HWND parent_window,
	std::unique_ptr<ChildWindow>* window,
	base::WaitableEvent* event) {
	*window = std::make_unique<ChildWindow>(parent_window);
	event->Signal();
	}

	} // namespace

	class VulkanSurfaceWin32::WindowThread : public base::Thread,
	public base::RefCounted<WindowThread> {
	public:
	WindowThread() : base::Thread("VulkanWindowThread") {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
	DCHECK(!g_thread);
	g_thread = this;
	base::Thread::Options options(base::MessagePumpType::UI, 0);
	StartWithOptions(std::move(options));
	}

	WindowThread(const WindowThread&) = delete;
	WindowThread& operator=(const WindowThread&) = delete;

	private:
	friend class base::RefCounted<WindowThread>;

	~WindowThread() override {
	DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
	DCHECK_EQ(g_thread, this);
	Stop();
	g_thread = nullptr;
	}

	THREAD_CHECKER(thread_checker_);
	};

	// static
	std::unique_ptr<VulkanSurfaceWin32> VulkanSurfaceWin32::Create(
	VkInstance vk_instance,
	HWND parent_window) {
	scoped_refptr<WindowThread> thread = g_thread;
	if (!thread) {
	// If there is no other VulkanSurfaceWin32, g_thread will be nullptr, and
	// we need to create a thread for running child window message loop.
	// Otherwise keep a ref of g_thread, so it will not be destroyed until the
	// this VulkanSurfaceWin32 is destroyed.
	thread = base::MakeRefCounted<WindowThread>();
	g_thread = thread.get();
	}

	// vkCreateSwapChainKHR() fails in sandbox with a window which is created by
	// other process with NVIDIA driver. Workaround the problem by creating a
	// child window and use it to create vulkan surface.
	// TODO(penghuang): Only apply this workaround with NVIDIA GPU?
	// https://crbug.com/1068742
	std::unique_ptr<ChildWindow> window;
	base::WaitableEvent event;
	thread->task_runner()->PostTask(
	FROM_HERE,
	base::BindOnce(&CreateChildWindow, parent_window, &window, &event));
	event.Wait();

	VkSurfaceKHR surface;
	VkWin32SurfaceCreateInfoKHR surface_create_info = {
	.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
	.hinstance = reinterpret_cast<HINSTANCE>(
	GetWindowLongPtr(window->hwnd(), GWLP_HINSTANCE)),
	.hwnd = window->hwnd(),
	};
	VkResult result = vkCreateWin32SurfaceKHR(vk_instance, &surface_create_info,
	nullptr, &surface);
	if (VK_SUCCESS != result) {
	LOG(DFATAL) << "vkCreatWin32SurfaceKHR() failed: " << result;
	return nullptr;
	}
	return std::make_unique<VulkanSurfaceWin32>(
	base::PassKey<VulkanSurfaceWin32>(), vk_instance, surface,
	std::move(thread), std::move(window));
	}

	VulkanSurfaceWin32::VulkanSurfaceWin32(
	base::PassKey<VulkanSurfaceWin32> pass_key,
	VkInstance vk_instance,
	VkSurfaceKHR vk_surface,
	scoped_refptr<WindowThread> thread,
	std::unique_ptr<gfx::WindowImpl> window)
	: VulkanSurface(vk_instance, window->hwnd(), vk_surface),
	thread_(std::move(thread)),
	window_(std::move(window)) {}

	VulkanSurfaceWin32::~VulkanSurfaceWin32() {
	thread_->task_runner()->DeleteSoon(FROM_HERE, std::move(window_));
	}

	bool VulkanSurfaceWin32::Reshape(const gfx::Size& size,
	gfx::OverlayTransform pre_transform) {
	DCHECK_EQ(pre_transform, gfx::OVERLAY_TRANSFORM_NONE);
	constexpr auto kFlags = SWP_NOMOVE \| SWP_NOACTIVATE \| SWP_NOCOPYBITS \|
	SWP_NOOWNERZORDER \| SWP_NOZORDER;
	if (!SetWindowPos(window_->hwnd(), nullptr, 0, 0, size.width(), size.height(),
	kFlags)) {
	PLOG(DFATAL) << "SetWindowPos() failed";
	return false;
	}
	return VulkanSurface::Reshape(size, pre_transform);
	}

	} // namespace gpu