Fix residue left over from find bar when using accelerated compositing

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 52 matching lines @@
 using WebKit::WebInputEvent;
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseEvent;
 using WebKit::WebTextDirection;
 using webkit::npapi::WebPluginGeometry;
 
 const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
 
 namespace {
 
+const TCHAR* kRenderWidgetHVWPropStr = _T("RWHVW_P");
+
 // 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;
 
@@ skipping 744 matching lines @@
 
   CleanupCompositorWindow();
 
   ResetTooltip();
   TrackMouseLeave(false);
 }
 
 void RenderWidgetHostViewWin::OnPaint(HDC unused_dc) {
   DCHECK(render_widget_host_->process()->HasConnection());
 
-  // If the GPU process is rendering directly into the View,
-  // call the compositor directly.
-  RenderWidgetHost* render_widget_host = GetRenderWidgetHost();
-  if (render_widget_host->is_accelerated_compositing_active()) {
+  // If the GPU process is rendering directly into the View, compositing is
+  // already triggered by damage to compositor_host_window_, so all we need to
+  // do here is clear borders during resize.
+  if (render_widget_host_ &&
+      render_widget_host_->is_accelerated_compositing_active()) {
     // We initialize paint_dc here so that BeginPaint()/EndPaint()
     // get called to validate the region.
     CPaintDC paint_dc(m_hWnd);
-    render_widget_host_->ScheduleComposite();
+    RECT host_rect, child_rect;
+    GetClientRect(&host_rect);
+    if (::GetClientRect(compositor_host_window_, &child_rect) &&
+        (child_rect.right < host_rect.right ||
+         child_rect.bottom < host_rect.bottom)) {
+      paint_dc.FillRect(&host_rect,
+          reinterpret_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)));
+    }
     return;
   }
 
   about_to_validate_and_paint_ = true;
   BackingStoreWin* backing_store = static_cast<BackingStoreWin*>(
       render_widget_host_->GetBackingStore(true));
 
   // We initialize |paint_dc| (and thus call BeginPaint()) after calling
   // GetBackingStore(), so that if it updates the invalid rect we'll catch the
   // changes and repaint them.
@@ skipping 617 matching lines @@
   // 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);
 }
 
 static void PaintCompositorHostWindow(HWND hWnd) {
   PAINTSTRUCT paint;
   BeginPaint(hWnd, &paint);
 
+  RenderWidgetHostViewWin* win = static_cast<RenderWidgetHostViewWin*>(
+      GetProp(hWnd, kRenderWidgetHVWPropStr));
+  // Trigger composite to rerender window.
+  win->ScheduleComposite();
+
   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;
   case WM_DESTROY:
+    RemoveProp(hWnd, kRenderWidgetHVWPropStr);
     return 0;
   case WM_PAINT:
     PaintCompositorHostWindow(hWnd);
     return 0;
   default:
     return DefWindowProc(hWnd, message, wParam, lParam);
   }
 }
 
+void RenderWidgetHostViewWin::ScheduleComposite() {
+  if (render_widget_host_)
+    render_widget_host_->ScheduleComposite();
+}
+
 // Creates a HWND within the RenderWidgetHostView that will serve as a host
 // for a HWND that the GPU process will create. The host window is used
 // to Z-position the GPU's window relative to other plugin windows.
 gfx::PluginWindowHandle RenderWidgetHostViewWin::GetCompositingSurface() {
   // If the window has been created, don't recreate it a second time
   if (compositor_host_window_)
     return compositor_host_window_;
 
   static ATOM window_class = 0;
   if (!window_class) {
@@ skipping 20 matching lines @@
   int width = currentRect.right - currentRect.left;
   int height = currentRect.bottom - currentRect.top;
 
   compositor_host_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, width, height, m_hWnd, 0, GetModuleHandle(NULL), 0);
   ui::CheckWindowCreated(compositor_host_window_);
 
+  SetProp(compositor_host_window_, kRenderWidgetHVWPropStr, this);

[Ben Goodger (Google), 2011/05/27 17:56:18]

SetProp() can be problematic, and can lead to strange crashes. There is a limit
to the amount of memory (system-wide I think!) that can be used for property
storage and so this function will eventually fail. We have a class called
ViewProp in src/ui that lets you associate properties with arbitrary
gfx::NativeViews, but in this case why not just set this as the window's user
data? We typically store a pointer to the C++ class that subclasses WindowImpl
as the user data.

[jbates, 2011/05/27 18:18:55]

User data sounds good to me. You mean SetWindowLongPtr(hwnd, GWLP_USERDATA,...)
right?

[Ben Goodger (Google), 2011/05/27 18:20:15]

Yes. There should be a win_util in base somewhere that does this for you.

[jbates, 2011/05/27 18:27:33]

I don't see anything like that in win_util or base. Is it OK to call
SetWindowLongPtr directly?

[Ben Goodger (Google), 2011/05/27 18:44:17]

Ah it got migrated to src/ui. But you're in src/chrome, so you're allowed to use
that:

src/ui/base/win/hwnd_util.h:

void* ui::SetWindowUserData(HWND hwnd, void* data);
void* ui::GetWindowUserData(HWND hwnd);

ui::GetWindowUserData does some checking to make sure if another process
clobbers your user data, you don't try a cast that'll crash.

[jbates, 2011/05/27 19:10:37]

Done.

+
   return static_cast<gfx::PluginWindowHandle>(compositor_host_window_);
 }
 
 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;
 
@@ skipping 224 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView native_view) {
   return ::IsWindow(native_view) ?
       reinterpret_cast<RenderWidgetHostView*>(
           ViewProp::GetValue(native_view, kRenderWidgetHostViewKey)) : NULL;
 }