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

chrome/browser/renderer_host/render_widget_host_view_win.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 "chrome/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
@@ skipping 62 matching lines @@
 // Tooltips will wrap after this width. Yes, wrap. Imagine that!
 const int kTooltipMaxWidthPixels = 300;
 
 // Maximum number of characters we allow in a tooltip.
 const int kMaxTooltipLength = 1024;
 
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 const int kIdCustom = 1;
 
+// The delay before the compositor host window is destroyed. This gives the GPU
+// process a grace period to stop referencing it.
+const int kDestroyCompositorHostWindowDelay = 10000;
+
 const char* const kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
 
 // A callback function for EnumThreadWindows to enumerate and dismiss
 // any owned popop windows
 BOOL CALLBACK DismissOwnedPopups(HWND window, LPARAM arg) {
   const HWND toplevel_hwnd = reinterpret_cast<HWND>(arg);
 
   if (::IsWindowVisible(window)) {
     const HWND owner = ::GetWindow(window, GW_OWNER);
     if (toplevel_hwnd == owner) {
@@ skipping 219 matching lines @@
   UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
       SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
 
   // If the style is not popup, you have to convert the point to client
   // coordinate.
   POINT point = { rect.x(), rect.y() };
   if (GetStyle() & WS_CHILD)
     ScreenToClient(&point);
 
   SetWindowPos(NULL, point.x, point.y, rect.width(), rect.height(), swp_flags);
-  if (compositor_host_window_) {
-    ::SetWindowPos(compositor_host_window_, NULL, point.x, point.y,
-        rect.width(), rect.height(),
-        SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER | SWP_NOACTIVATE);
-  }
   render_widget_host_->WasResized();
   EnsureTooltip();
 }
 
 gfx::NativeView RenderWidgetHostViewWin::GetNativeView() {
   return m_hWnd;
 }
 
 void RenderWidgetHostViewWin::MovePluginWindows(
     const std::vector<WebPluginGeometry>& plugin_window_moves) {
@@ skipping 118 matching lines @@
 static BOOL CALLBACK AddChildWindowToVector(HWND hwnd, LPARAM lparam) {
   std::vector<HWND>* vector = reinterpret_cast<std::vector<HWND>*>(lparam);
   vector->push_back(hwnd);
   return TRUE;
 }
 
 void RenderWidgetHostViewWin::CleanupCompositorWindow() {
   if (!compositor_host_window_)
     return;
 
-  std::vector<HWND> all_child_windows;
-  ::EnumChildWindows(compositor_host_window_, AddChildWindowToVector,
-    reinterpret_cast<LPARAM>(&all_child_windows));
-  if (all_child_windows.size()) {
-    DCHECK(all_child_windows.size() == 1);
-    ::ShowWindow(all_child_windows[0], SW_HIDE);
-    ::SetParent(all_child_windows[0], NULL);
-  }
+  // Hide the compositor and parent it to the desktop rather than destroying
+  // it immediately. The GPU process has a grace period to stop accessing the
+  // window. TODO(apatrick): the GPU process should acknowledge that it has
+  // finished with the window handle and the browser process should destroy it
+  // at that point.
+  ::ShowWindow(compositor_host_window_, SW_HIDE);
+  ::SetParent(compositor_host_window_, NULL);
+
+  BrowserThread::PostDelayedTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      NewRunnableFunction(::DestroyWindow, compositor_host_window_),
+      kDestroyCompositorHostWindowDelay);
+
   compositor_host_window_ = NULL;
 }
 
 bool RenderWidgetHostViewWin::IsActivatable() const {
   // Popups should not be activated.
   return popup_type_ == WebKit::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewWin::Focus() {
   if (IsWindow())
@@ skipping 976 matching lines @@
   if (!render_widget_host_ ||
       render_process_host != render_widget_host_->process())
     return;
 
   // If it was our RenderProcessHost that posted the notification,
   // clear the BrowserAccessibilityManager, because the renderer is
   // dead and any accessibility information we have is now stale.
   browser_accessibility_manager_.reset(NULL);
 }
 
-// Looks through the children windows of the CompositorHostWindow. If the
-// compositor child window is found, its size is checked against the host
-// window's size. If the child is smaller in either dimensions, we fill
-// the host window with white to avoid unseemly cracks.
 static void PaintCompositorHostWindow(HWND hWnd) {
   PAINTSTRUCT paint;
   BeginPaint(hWnd, &paint);
 
-  std::vector<HWND> child_windows;
-  EnumChildWindows(hWnd, AddChildWindowToVector,
-      reinterpret_cast<LPARAM>(&child_windows));
-
-  if (child_windows.size()) {
-    HWND child = child_windows[0];
-
-    RECT host_rect, child_rect;
-    GetClientRect(hWnd, &host_rect);
-    if (GetClientRect(child, &child_rect)) {
-      if (child_rect.right < host_rect.right ||
-         child_rect.bottom != host_rect.bottom) {
-          FillRect(paint.hdc, &host_rect,
-              static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)));
-      }
-    }
-  }
   EndPaint(hWnd, &paint);
 }
 
 // WndProc for the compositor host window. We use this instead of Default so
 // we can drop WM_PAINT and WM_ERASEBKGD messages on the floor.
 static LRESULT CALLBACK CompositorHostWindowProc(HWND hWnd, UINT message,
                                                  WPARAM wParam, LPARAM lParam) {
   switch (message) {
   case WM_ERASEBKGND:
     return 0;
@@ skipping 51 matching lines @@
 }
 
 void RenderWidgetHostViewWin::ShowCompositorHostWindow(bool show) {
   // When we first create the compositor, we will get a show request from
   // the renderer before we have gotten the create request from the GPU. In this
   // case, simply ignore the show request.
   if (compositor_host_window_ == NULL)
     return;
 
   if (show) {
-    UINT flags = SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER |
-      SWP_NOACTIVATE | SWP_DEFERERASE | SWP_SHOWWINDOW;
-    gfx::Rect rect = GetViewBounds();
-    ::SetWindowPos(compositor_host_window_, NULL, 0, 0,
-        rect.width(), rect.height(),
-        flags);
+    ::ShowWindow(compositor_host_window_, SW_SHOW);
 
     // Get all the child windows of this view, including the compositor window.
     std::vector<HWND> all_child_windows;
     ::EnumChildWindows(m_hWnd, AddChildWindowToVector,
         reinterpret_cast<LPARAM>(&all_child_windows));
 
     // Build a list of just the plugin window handles
     std::vector<HWND> plugin_windows;
     bool compositor_host_window_found = false;
     for (size_t i = 0; i < all_child_windows.size(); ++i) {
@@ skipping 218 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView native_view) {
   return ::IsWindow(native_view) ?
       reinterpret_cast<RenderWidgetHostView*>(
           ViewProp::GetValue(native_view, kRenderWidgetHostViewKey)) : NULL;
 }