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 131 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewWin(widget);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewWin, public:
 
 RenderWidgetHostViewWin::RenderWidgetHostViewWin(RenderWidgetHost* widget)
     : render_widget_host_(widget),
       compositor_host_window_(NULL),
+      was_compositing_just_scheduled_(false),
       hide_compositor_window_at_next_paint_(false),
       track_mouse_leave_(false),
       ime_notification_(false),
       capture_enter_key_(false),
       is_hidden_(false),
       about_to_validate_and_paint_(false),
       close_on_deactivate_(false),
       being_destroyed_(false),
       tooltip_hwnd_(NULL),
       tooltip_showing_(false),
       shutdown_factory_(this),
+      method_factory_(this),
       parent_hwnd_(NULL),
       is_loading_(false),
       overlay_color_(0),
       text_input_type_(WebKit::WebTextInputTypeNone) {
   render_widget_host_->set_view(this);
   registrar_.Add(this,
                  NotificationType::RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllSources());
 }
 
@@ skipping 587 matching lines @@
 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()) {
     // We initialize paint_dc here so that BeginPaint()/EndPaint()
     // get called to validate the region.
     CPaintDC paint_dc(m_hWnd);
-    render_widget_host_->ScheduleComposite();
+    ScheduleCompositeIfNeeded();
     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));
+  // May block unless parent window already did this.
+  win->ScheduleCompositeIfNeeded();
+
   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::ScheduleCompositeIfNeeded() {
+  // Call ScheduleComposite unless it has already occured during this set of
+  // Windows events.
+  if (!was_compositing_just_scheduled_) {
+    was_compositing_just_scheduled_ = true;
+    render_widget_host_->ScheduleComposite();
+    MessageLoop::current()->PostTask(FROM_HERE,

[darin (slow to review), 2011/05/26 23:03:06]

Maybe I don't understand what you are trying to accomplish, but won't
ResetWasCompositingJustScheduled be racing with receipt of the
ViewHostMsg_UpdateRect IPC?

RenderWidgetHost::ScheduleComposite will sometimes process
ViewHostMsg_UpdateRect before returning, but that is not guaranteed.

Maybe it would be helpful if I understood why you need to limit calls to
ScheduleComposite.

[jbates, 2011/05/27 17:11:41]

You're right - it's a mistake. The latest version is much simpler.

+        method_factory_.NewRunnableMethod(
+            &RenderWidgetHostViewWin::ResetWasCompositingJustScheduled));
+  }
+}
+
+void RenderWidgetHostViewWin::ResetWasCompositingJustScheduled() {
+  was_compositing_just_scheduled_ = false;
+}
+
 // 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);
+
   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;
 }