Fix Silverlight windowless plugin painting issues. This fixes the following...

chrome/plugin/webplugin_proxy.cc

 // Copyright (c) 2006-2008 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/plugin/webplugin_proxy.h"
 
 #include "base/gfx/gdi_util.h"
 #include "base/gfx/platform_device_win.h"
 #include "base/scoped_handle.h"
 #include "base/shared_memory.h"
@@ skipping 16 matching lines @@
     PluginChannel* channel,
     int route_id,
     WebPluginDelegateImpl* delegate,
     HANDLE modal_dialog_event)
     : channel_(channel),
       route_id_(route_id),
       cp_browsing_context_(0),
       window_npobject_(NULL),
       plugin_element_(NULL),
       delegate_(delegate),
-      waiting_for_paint_(false) {
+      waiting_for_paint_(false),
+#pragma warning(suppress: 4355)  // can use this
+      runnable_method_factory_(this) {
 
   HANDLE event;
   BOOL result = DuplicateHandle(channel->renderer_handle(),
       modal_dialog_event,
       GetCurrentProcess(),
       &event,
       SYNCHRONIZE,
       FALSE,
       0);
   DCHECK(result) << "Couldn't duplicate the modal dialog handle for the plugin.";
@@ skipping 29 matching lines @@
   Send(new PluginHostMsg_CancelResource(route_id_, id));
   resource_clients_.erase(id);
 }
 
 void WebPluginProxy::Invalidate() {
   gfx::Rect rect(0, 0, delegate_->rect().width(), delegate_->rect().height());
   InvalidateRect(rect);
 }
 
 void WebPluginProxy::InvalidateRect(const gfx::Rect& rect) {
+  damaged_rect_ = damaged_rect_.Union(rect);
   // Ignore NPN_InvalidateRect calls with empty rects.  Also don't send an
   // invalidate if it's outside the clipping region, since if we did it won't
   // lead to a paint and we'll be stuck waiting forever for a DidPaint response.
   if (rect.IsEmpty() || !delegate_->clip_rect().Intersects(rect))
     return;
 
-  damaged_rect_ = damaged_rect_.Union(rect);
   // Only send a single InvalidateRect message at a time.  From DidPaint we
   // will dispatch an additional InvalidateRect message if necessary.
   if (!waiting_for_paint_) {
     waiting_for_paint_ = true;
-    // Paint to the plugin bitmap and let the renderer know so it can update
-    // its backing store.
-    Paint(damaged_rect_);
-    Send(new PluginHostMsg_InvalidateRect(route_id_, damaged_rect_));
+    // Invalidates caused by calls to NPN_InvalidateRect/NPN_InvalidateRgn
+    // need to be painted asynchronously as per the NPAPI spec.
+    MessageLoop::current()->PostTask(FROM_HERE,
+        runnable_method_factory_.NewRunnableMethod(
+            &WebPluginProxy::OnPaint, damaged_rect_));
     damaged_rect_ = gfx::Rect();
   }
 }
 
 NPObject* WebPluginProxy::GetWindowScriptNPObject() {
   if (window_npobject_)
     return NPN_RetainObject(window_npobject_);
 
   int npobject_route_id = channel_->GenerateRouteID();
   bool success = false;
@@ skipping 163 matching lines @@
 }
 
 void WebPluginProxy::UpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect,
     const std::vector<gfx::Rect>& cutout_rects,
     bool visible,
     const base::SharedMemoryHandle& windowless_buffer,
     const base::SharedMemoryHandle& background_buffer) {
   gfx::Rect old = delegate_->rect();
+  gfx::Rect old_clip_rect = delegate_->clip_rect();
+
   bool moved = delegate_->rect().x() != window_rect.x() ||
                delegate_->rect().y() != window_rect.y();
   delegate_->UpdateGeometry(window_rect, clip_rect, cutout_rects, visible);
   if (windowless_buffer) {
     // The plugin's rect changed, so now we have a new buffer to draw into.
     SetWindowlessBuffer(windowless_buffer, background_buffer);
   } else if (moved) {
     // The plugin moved, so update our world transform.
     UpdateTransform();
   }
+  // Send over any pending invalidates which occured when the plugin was
+  // off screen.
+  if (visible && delegate_->windowless() && !clip_rect.IsEmpty() &&
+      old_clip_rect.IsEmpty() && !damaged_rect_.IsEmpty()) {
+    InvalidateRect(damaged_rect_);
+  }
 }
 
 void WebPluginProxy::SetWindowlessBuffer(
     const base::SharedMemoryHandle& windowless_buffer,
     const base::SharedMemoryHandle& background_buffer) {
   // Convert the shared memory handle to a handle that works in our process,
   // and then use that to create an HDC.
   ConvertBuffer(windowless_buffer,
                 &windowless_shared_section_,
                 &windowless_bitmap_,
@@ skipping 64 matching lines @@
 void WebPluginProxy::InitiateHTTPRangeRequest(const char* url,
                                               const char* range_info,
                                               void* existing_stream,
                                               bool notify_needed,
                                               HANDLE notify_data) {
 
   Send(new PluginHostMsg_InitiateHTTPRangeRequest(route_id_, url,
                                                   range_info, existing_stream,
                                                   notify_needed, notify_data));
 }
+
+void WebPluginProxy::OnPaint(const gfx::Rect& damaged_rect) {
+  Paint(damaged_rect);
+  Send(new PluginHostMsg_InvalidateRect(route_id_, damaged_rect));
+}