Removed "compositor" child window that was created by the GPU process.

content/common/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "content/common/child_thread.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_watchdog.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/common/gpu_trace_event.h"
 #include "ui/gfx/gl/gl_context.h"
+#include "ui/gfx/gl/gl_surface.h"
 
 #if defined(OS_WIN)
 #include "base/win/wrapped_window_proc.h"
 #endif
 
 using gpu::Buffer;
 
 #if defined(OS_WIN)
 #define kCompositorWindowOwner L"CompositorWindowOwner"
 #endif  // defined(OS_WIN)
@@ skipping 14 matching lines @@
     : channel_(channel),
       handle_(handle),
       parent_(
           parent ? parent->AsWeakPtr() : base::WeakPtr<GpuCommandBufferStub>()),
       initial_size_(size),
       disallowed_extensions_(disallowed_extensions),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       parent_texture_id_(parent_texture_id),
       route_id_(route_id),
-#if defined(OS_WIN)
-      compositor_window_(NULL),
-#endif  // defined(OS_WIN)
       renderer_id_(renderer_id),
       render_view_id_(render_view_id),
       watchdog_(watchdog) {
 }
 
-#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:
-      RemoveProp(hwnd, kCompositorWindowOwner);
-      return 0;
-    case WM_PAINT: {
-      PAINTSTRUCT paint;
-      HDC dc = BeginPaint(hwnd, &paint);
-      if (dc) {
-        HANDLE h = GetProp(hwnd, kCompositorWindowOwner);
-        if (h) {
-          GpuCommandBufferStub* stub =
-              reinterpret_cast<GpuCommandBufferStub*>(h);
-          stub->OnCompositorWindowPainted();
-        }
-        EndPaint(hwnd, &paint);
-      }
-      break;
-    }
-    default:
-      return DefWindowProc(hwnd, message, wparam, lparam);
-  }
-  return 0;
-}
-
-bool GpuCommandBufferStub::CreateCompositorWindow() {
-  DCHECK(handle_ != gfx::kNullPluginWindow);
-  HWND host_window = static_cast<HWND>(handle_);
-
-  // 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    = base::win::WrappedWindowProc<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);
-  if (!compositor_window) {
-    compositor_window_ = gfx::kNullPluginWindow;
-    return false;
-  }
-  SetProp(compositor_window, kCompositorWindowOwner,
-      reinterpret_cast<HANDLE>(this));
-
-  RECT parent_rect;
-  GetClientRect(host_window, &parent_rect);
-
-  UINT flags = SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER |
-      SWP_NOACTIVATE | SWP_DEFERERASE | SWP_SHOWWINDOW;
-  SetWindowPos(compositor_window,
-      NULL,
-      0, 0,
-      parent_rect.right - parent_rect.left,
-      parent_rect.bottom - parent_rect.top,
-      flags);
-  compositor_window_ = static_cast<gfx::PluginWindowHandle>(compositor_window);
-  return true;
-}
-
-void GpuCommandBufferStub::OnCompositorWindowPainted() {
-  GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-  gpu_channel_manager->Send(new GpuHostMsg_ScheduleComposite(
-      renderer_id_, render_view_id_));
-}
-#endif  // defined(OS_WIN)
-
-
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   if (scheduler_.get()) {
     scheduler_->Destroy();
   }
-#if defined(OS_WIN)
-  if (compositor_window_) {
-    DestroyWindow(static_cast<HWND>(compositor_window_));
-    compositor_window_ = NULL;
-  }
-#endif  // defined(OS_WIN)
 
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(
       handle_, renderer_id_, render_view_id_));
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
@@ skipping 27 matching lines @@
 void GpuCommandBufferStub::OnInitialize(
     base::SharedMemoryHandle ring_buffer,
     int32 size,
     bool* result) {
   DCHECK(!command_buffer_.get());
 
   *result = false;
 
   command_buffer_.reset(new gpu::CommandBufferService);
 
-  // Create the child window, if needed
-#if defined(OS_WIN)
-  gfx::PluginWindowHandle output_window_handle;
-  if (handle_) {
-    if (!CreateCompositorWindow()) {
-      return;
-    }
-    output_window_handle = compositor_window_;
-  } else {
-    output_window_handle = handle_;
-  }
-#else
-  gfx::PluginWindowHandle output_window_handle = handle_;
-#endif  // defined(OS_WIN)
-
 #if defined(OS_WIN)
   // Windows dups the shared memory handle it receives into the current process
   // and closes it when this variable goes out of scope.
   base::SharedMemory shared_memory(ring_buffer,
                                    false,
                                    channel_->renderer_process());
 #else
   // POSIX receives a dup of the shared memory handle and closes the dup when
   // this variable goes out of scope.
   base::SharedMemory shared_memory(ring_buffer, false);
 #endif
 
   // Initialize the CommandBufferService and GpuScheduler.
   if (command_buffer_->Initialize(&shared_memory, size)) {
     gpu::GpuScheduler* parent_processor =
         parent_ ? parent_->scheduler_.get() : NULL;
     scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(), NULL));
     if (scheduler_->Initialize(
-        output_window_handle,
+        handle_,
         initial_size_,
         disallowed_extensions_,
         allowed_extensions_.c_str(),
         requested_attribs_,
         parent_processor,
         parent_texture_id_)) {
       command_buffer_->SetPutOffsetChangeCallback(
           NewCallback(scheduler_.get(),
                       &gpu::GpuScheduler::ProcessCommands));
       scheduler_->SetSwapBuffersCallback(
@@ skipping 151 matching lines @@
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.renderer_id = renderer_id_;
   params.render_view_id = render_view_id_;
   params.window = handle_;
   params.surface_id = scheduler_->GetSurfaceId();
   params.route_id = route_id();
   params.swap_buffers_count = scheduler_->swap_buffers_count();
   gpu_channel_manager->Send(
       new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
+
+  scheduler_->SetScheduled(false);
 }
 
 void GpuCommandBufferStub::AcceleratedSurfaceBuffersSwapped(
     uint64 swap_buffers_count) {
   scheduler_->set_acknowledged_swap_buffers_count(swap_buffers_count);
+
   // Wake up the GpuScheduler to start doing work again.
-  scheduler_->ScheduleProcessCommands();
+  scheduler_->SetScheduled(true);
 }
 #endif  // defined(OS_MACOSX)
 
 void GpuCommandBufferStub::ResizeCallback(gfx::Size size) {
   if (handle_ == gfx::kNullPluginWindow) {
     scheduler_->decoder()->ResizeOffscreenFrameBuffer(size);
     scheduler_->decoder()->UpdateOffscreenFrameBufferSize();
   } else {
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
+#if defined(OS_LINUX) && !defined(TOUCH_UI) || defined(OS_WIN)
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-    bool result = false;
     gpu_channel_manager->Send(
-        new GpuHostMsg_ResizeXID(handle_, size, &result));
-#elif defined(OS_WIN)
-    HWND hwnd = static_cast<HWND>(compositor_window_);
-    UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
-      SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
-    SetWindowPos(hwnd, NULL, 0, 0, size.width(), size.height(), swp_flags);
-#endif  // defined(OS_LINUX)
+        new GpuHostMsg_ResizeView(renderer_id_,
+                                  render_view_id_,
+                                  route_id_,
+                                  size));
+
+    scheduler_->SetScheduled(false);
+#endif
   }
 }
 
+void GpuCommandBufferStub::ViewResized() {
+#if defined(OS_LINUX) && !defined(TOUCH_UI) || defined(OS_WIN)
+  DCHECK(handle_ != gfx::kNullPluginWindow);
+  scheduler_->SetScheduled(true);
+
+  // Recreate the view surface to match the window size. TODO(apatrick): this is
+  // likely not necessary on all platforms.
+  gfx::GLContext* context = scheduler_->decoder()->GetGLContext();
+  context->ReleaseCurrent();
+  gfx::GLSurface* surface = context->GetSurface();
+  if (surface) {
+    surface->Destroy();
+    surface->Initialize();
+  }
+#endif
+}
+
 #endif  // defined(ENABLE_GPU)