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

content/browser/gpu_process_host_ui_shim.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.
 
 #include "content/browser/gpu_process_host_ui_shim.h"
 
 #include "base/command_line.h"
 #include "base/id_map.h"
 #include "base/process_util.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 206 matching lines @@
   }
 }
 
 bool GpuProcessHostUIShim::OnControlMessageReceived(
     const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHostUIShim, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_OnLogMessage,
                         OnLogMessage)
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_ResizeXID, OnResizeXID)
+#if defined(OS_LINUX) && !defined(TOUCH_UI) || defined(OS_WIN)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_ResizeView, OnResizeView)
 #elif defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSetIOSurface,
                         OnAcceleratedSurfaceSetIOSurface)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
                         OnAcceleratedSurfaceBuffersSwapped)
 #elif defined(OS_WIN)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ScheduleComposite, OnScheduleComposite);
 #endif
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHostUIShim::OnLogMessage(
     int level,
     const std::string& header,
     const std::string& message) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("level", level);
   dict->SetString("header", header);
   dict->SetString("message", message);
   GpuDataManager::GetInstance()->AddLogMessage(dict);
 }
 
+#if defined(OS_LINUX) && !defined(TOUCH_UI) || defined(OS_WIN)
+
+void GpuProcessHostUIShim::OnResizeView(int32 renderer_id,
+                                        int32 render_view_id,
+                                        int32 command_buffer_route_id,
+                                        gfx::Size size) {
+  RenderViewHost* host = RenderViewHost::FromID(renderer_id, render_view_id);
+  if (host) {
+    RenderWidgetHostView* view = host->view();
+    if (view) {
+      gfx::PluginWindowHandle handle = view->GetCompositingSurface();
+
+      // Resize the window synchronously. The GPU process must not issue GL
+      // calls on the command buffer until the window is the size it expects it
+      // to be.
 #if defined(OS_LINUX) && !defined(TOUCH_UI)
-
-void GpuProcessHostUIShim::OnResizeXID(unsigned long xid, gfx::Size size,
-                                       IPC::Message *reply_msg) {
-  GdkWindow* window = reinterpret_cast<GdkWindow*>(gdk_xid_table_lookup(xid));
-  if (window) {
-    Display* display = GDK_WINDOW_XDISPLAY(window);
-    gdk_window_resize(window, size.width(), size.height());
-    XSync(display, False);
+      GdkWindow* window = reinterpret_cast<GdkWindow*>(
+          gdk_xid_table_lookup(handle));
+      if (window) {
+        Display* display = GDK_WINDOW_XDISPLAY(window);
+        gdk_window_resize(window, size.width(), size.height());
+        XSync(display, False);
+      }
+#elif defined(OS_WIN)
+      SetWindowPos(handle,
+          NULL,
+          0, 0,
+          size.width(),
+          size.height(),
+          SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER |
+              SWP_NOACTIVATE | SWP_DEFERERASE | SWP_SHOWWINDOW);
+#endif
+    }
   }
 
-  GpuHostMsg_ResizeXID::WriteReplyParams(reply_msg, (window != NULL));
-  Send(reply_msg);
+  // Always respond even if the window no longer exists. The GPU process cannot
+  // make progress on the resizing command buffer until it receives the
+  // response.
+  Send(new GpuMsg_ResizeViewACK(renderer_id, command_buffer_route_id));
 }
 
 #elif defined(OS_MACOSX)
 
 void GpuProcessHostUIShim::OnAcceleratedSurfaceSetIOSurface(
     const GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params& params) {
   RenderViewHost* host = RenderViewHost::FromID(params.renderer_id,
                                                 params.render_view_id);
   if (!host)
     return;
@@ skipping 19 matching lines @@
       // Parameters needed to swap the IOSurface.
       params.window,
       params.surface_id,
       // Parameters needed to formulate an acknowledgment.
       params.renderer_id,
       params.route_id,
       host_id_,
       params.swap_buffers_count);
 }
 
-#elif defined(OS_WIN)
+#endif
+
+#if defined(OS_WIN)
 
 void GpuProcessHostUIShim::OnScheduleComposite(int renderer_id,
     int render_view_id) {
   RenderViewHost* host = RenderViewHost::FromID(renderer_id,
                                                 render_view_id);
   if (!host) {
     return;
   }
   host->ScheduleComposite();
 }
 
 #endif