// 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