Use inner HWND for accelerated rendering on windows

chrome/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2010 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/common/child_thread.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/gpu/gpu_channel.h"
 #include "chrome/gpu/gpu_command_buffer_stub.h"
 
 using gpu::Buffer;
 
+#define kCompositorWindowOwner L"kCompositorWindowOwner"

[apatrick_chromium, 2010/11/19 23:09:51]

nit: make this const wchar_t[]

[nduca, 2010/11/20 00:28:49]

Other code that does this follows the define pattern, e.g. plugin_constants_win.


(On 2010/11/19 23:09:51, apatrick_chromium wrote:

+
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     gfx::PluginWindowHandle handle,
     GpuCommandBufferStub* parent,
     const gfx::Size& size,
     const std::string& allowed_extensions,
     const std::vector<int32>& attribs,
     uint32 parent_texture_id,
     int32 route_id,
     int32 renderer_id,
     int32 render_view_id)
     : channel_(channel),
       handle_(handle),
       parent_(
           parent ? parent->AsWeakPtr() : base::WeakPtr<GpuCommandBufferStub>()),
       initial_size_(size),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       parent_texture_id_(parent_texture_id),
       route_id_(route_id),
       renderer_id_(renderer_id),
       render_view_id_(render_view_id) {
 }
 
+#if defined(OS_WIN)
+static LRESULT CALLBACK CompositorWindowProc(
+    HWND hwnd,
+    UINT message,
+    WPARAM wparam,
+    LPARAM lparam) {
+  switch (message) {
+    case WM_ERASEBKGND:
+      return 0;
+    case WM_DESTROY:
+      return 0;
+    case WM_PAINT: {
+      PAINTSTRUCT paint;
+      BeginPaint(hwnd, &paint);

[apatrick_chromium, 2010/11/19 23:09:51]

Check this doesn't return null and don't call EndPaint if it does. It probably
doesn't matter if OnCompitorWindowPainted gets called in that case since
everything has gone horribly wrong.

[nduca, 2010/11/20 00:28:49]

Done.

+      HANDLE h = GetProp(hwnd, kCompositorWindowOwner);

[apatrick_chromium, 2010/11/19 23:09:51]

Check this does not return null before calling OnCompositorWindowPainted.

[nduca, 2010/11/20 00:28:49]

Done.

+      GpuCommandBufferStub* stub = reinterpret_cast<GpuCommandBufferStub*>(h);
+      stub->OnCompositorWindowPainted();
+      EndPaint(hwnd, &paint);
+      break;
+    }
+    default:
+      return DefWindowProc(hwnd, message, wparam, lparam);
+  }
+  return 0;
+}
+
+void GpuCommandBufferStub::CreateCompositorWindow() {
+  DCHECK(handle_ != gfx::kNullPluginWindow);
+
+  // Ask the browser to create the the host window.
+  ChildThread* gpu_thread = ChildThread::current();

[apatrick_chromium, 2010/11/19 23:09:51]

nit: add a pointer from GpuCommandBufferStub to GpuThread. Having multiple
GpuThreads is something that might happen in the future.

[nduca, 2010/11/20 00:28:49]

I don't see why that would affect this call. Are you saying that these threads
may not have their Send wired up to route to the GpuProcessHost?

On 2010/11/19 23:09:51, apatrick_chromium wrote:

+  gfx::PluginWindowHandle host_window_id;
+  gpu_thread->Send(new GpuHostMsg_CreateCompositorHostWindow(
+      renderer_id_,
+      render_view_id_,
+      &host_window_id));
+  HWND host_window = static_cast<HWND>(host_window_id);

[apatrick_chromium, 2010/11/19 23:09:51]

If Send fails, host_window_id will be uninitialized here. You might want
CreateCompositorWindow to return a bool indicating whether it succeeded.

[nduca, 2010/11/20 00:28:49]

If send fails, it means browser is dead. We're terribly horribly screwed. If
CreateCompositorWindow fails browser side, we're terribly horribly screwed. That
is to say, I'm not convinced error handling or recovery is needed here.

On 2010/11/19 23:09:51, apatrick_chromium wrote:

+
+  // Create the compositor window itself.
+  DCHECK(host_window);
+  static ATOM window_class = 0;
+  if (!window_class) {
+    WNDCLASSEX wcex;
+    wcex.cbSize         = sizeof(wcex);
+    wcex.style          = 0;
+    wcex.lpfnWndProc    = CompositorWindowProc;
+    wcex.cbClsExtra     = 0;
+    wcex.cbWndExtra     = 0;
+    wcex.hInstance      = GetModuleHandle(NULL);
+    wcex.hIcon          = 0;
+    wcex.hCursor        = 0;
+    wcex.hbrBackground  = NULL;
+    wcex.lpszMenuName   = 0;
+    wcex.lpszClassName  = L"CompositorWindowClass";
+    wcex.hIconSm        = 0;
+    window_class = RegisterClassEx(&wcex);
+    DCHECK(window_class);
+  }
+
+  HWND compositor_window = CreateWindowEx(
+      WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
+      MAKEINTATOM(window_class),
+      0,
+      WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_DISABLED,
+      0, 0,
+      0, 0,
+      host_window,
+      0,
+      GetModuleHandle(NULL),
+      0);
+  DCHECK(compositor_window);

[apatrick_chromium, 2010/11/19 23:09:51]

I think this might legitimately fail. It might be an idea to have
CreateCompositorWindow return false in that case.

[nduca, 2010/11/20 00:28:49]

Done.

+  SetProp(compositor_window, kCompositorWindowOwner,
+      reinterpret_cast<HANDLE>(this));
+
+  RECT parent_rect;
+  GetClientRect(host_window, &parent_rect);

[apatrick_chromium, 2010/11/19 23:09:51]

If the host window is destroyed for any reason, this will fail and parent_rect
will be uninitialized and potentially enormous if interpreted as valid below.

[nduca, 2010/11/20 00:28:49]

Done.

+
+  UINT flags = SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER |
+      SWP_NOACTIVATE | SWP_DEFERERASE | SWP_SHOWWINDOW;
+  SetWindowPos(compositor_window,

[apatrick_chromium, 2010/11/19 23:09:51]

nit: can you drop this argument to the next line and line it up with the others.

+      NULL,
+      0, 0,
+      parent_rect.right - parent_rect.left,
+      parent_rect.bottom - parent_rect.top,
+      flags);
+  compositor_window_ = static_cast<gfx::PluginWindowHandle>(compositor_window);
+}
+
+void GpuCommandBufferStub::OnCompositorWindowPainted() {
+  ChildThread* gpu_thread = ChildThread::current();

[apatrick_chromium, 2010/11/19 23:09:51]

See comment about GpuThread above.

[nduca, 2010/11/20 00:28:49]

Not sold on this being necessary.

+  gpu_thread->Send(new GpuHostMsg_ScheduleComposite(
+      renderer_id_, render_view_id_));
+}
+#endif  // defined(OS_WIN)
+
+
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   if (processor_.get()) {
     processor_->Destroy();
   }
+#if defined(OS_WIN)
+  if (compositor_window_) {
+    RemoveProp(compositor_window_, kCompositorWindowOwner);
+    DestroyWindow(static_cast<HWND>(compositor_window_));
+    compositor_window_ = NULL;
+  }
+#endif
 }
 
 void GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetState, OnGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncGetState, OnAsyncGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Flush, OnFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateTransferBuffer,
@@ skipping 17 matching lines @@
 
 void GpuCommandBufferStub::OnInitialize(
     int32 size,
     base::SharedMemoryHandle* ring_buffer) {
   DCHECK(!command_buffer_.get());
 
   *ring_buffer = base::SharedMemory::NULLHandle();
 
   command_buffer_.reset(new gpu::CommandBufferService);
 
+  // Create the child window, if needed
+#if defined(OS_WIN)
+  CreateCompositorWindow();

[apatrick_chromium, 2010/11/19 23:09:51]

Check if this fails.

[nduca, 2010/11/20 00:28:49]

Done.

+  gfx::PluginWindowHandle output_window_handle = compositor_window_;
+#else
+  gfx::PluginWindowHandle output_window_handle = handle_;
+#endif
+
   // Initialize the CommandBufferService and GPUProcessor.
   if (command_buffer_->Initialize(size)) {
     Buffer buffer = command_buffer_->GetRingBuffer();
     if (buffer.shared_memory) {
       gpu::GPUProcessor* parent_processor =
           parent_ ? parent_->processor_.get() : NULL;
       processor_.reset(new gpu::GPUProcessor(command_buffer_.get(), NULL));
       if (processor_->Initialize(
-          handle_,
+          output_window_handle,
           initial_size_,
           allowed_extensions_.c_str(),
           requested_attribs_,
           parent_processor,
           parent_texture_id_)) {
         command_buffer_->SetPutOffsetChangeCallback(
             NewCallback(processor_.get(),
                         &gpu::GPUProcessor::ProcessCommands));
         processor_->SetSwapBuffersCallback(
             NewCallback(this, &GpuCommandBufferStub::OnSwapBuffers));
@@ skipping 96 matching lines @@
 }
 
 void GpuCommandBufferStub::SwapBuffersCallback() {
   ChildThread* gpu_thread = ChildThread::current();
   gpu_thread->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(
       renderer_id_, render_view_id_, handle_, processor_->GetSurfaceId()));
 }
 #endif  // defined(OS_MACOSX)
 
 #endif  // ENABLE_GPU