Fix the painting problem with Stree View and Flash 10. After the size of the...

chrome/renderer/webplugin_delegate_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/renderer/webplugin_delegate_proxy.h"
 
 #include <atlbase.h>
 
 #include "generated_resources.h"
 
@@ skipping 120 matching lines @@
 }
 
 WebPluginDelegateProxy::WebPluginDelegateProxy(const std::string& mime_type,
                                                const std::string& clsid,
                                                RenderView* render_view)
     : render_view_(render_view),
       mime_type_(mime_type),
       clsid_(clsid),
       plugin_(NULL),
       windowless_(false),
-      first_paint_(true),
       npobject_(NULL),
       send_deferred_update_geometry_(false),
       visible_(false),
       sad_plugin_(NULL),
       window_script_object_(NULL),
       transparent_(false),
       invalidate_pending_(false) {
 }
 
 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
@@ skipping 235 matching lines @@
   return 4 * rect.width() * rect.height();
 }
 
 void WebPluginDelegateProxy::ResetWindowlessBitmaps() {
   backing_store_.reset();
   transport_store_.reset();
   backing_store_canvas_.reset();
   transport_store_canvas_.reset();
   background_store_.reset();
   background_store_canvas_.release();
+  backing_store_painted_ = gfx::Rect();
 }
 
 bool WebPluginDelegateProxy::CreateBitmap(
     scoped_ptr<base::SharedMemory>* memory,
     scoped_ptr<gfx::PlatformCanvasWin>* canvas) {
   size_t size = GetPaintBufSize(plugin_rect_);
   scoped_ptr<base::SharedMemory> new_shared_memory(new base::SharedMemory());
   if (!new_shared_memory->Create(L"", false, true, size))
     return false;
 
   scoped_ptr<gfx::PlatformCanvasWin> new_canvas(new gfx::PlatformCanvasWin);
   if (!new_canvas->initialize(plugin_rect_.width(), plugin_rect_.height(),
                               true, new_shared_memory->handle())) {
     return false;
   }
 
   memory->swap(new_shared_memory);
   canvas->swap(new_canvas);
   return true;
 }
 
 void WebPluginDelegateProxy::Paint(HDC hdc, const gfx::Rect& damaged_rect) {
   // If the plugin is no longer connected (channel crashed) draw a crashed
   // plugin bitmap
   if (!channel_host_->channel_valid()) {
     PaintSadPlugin(hdc, damaged_rect);
     return;
   }
 
-  // No paint events for windowed plugins.  However, if it is the first paint
-  // we don't know yet whether the plugin is windowless or not, so we have to
-  // send the event.
-  if (!windowless_ && !first_paint_) {
-    // TODO(maruel): That's not true for printing and thumbnail capture.
-    // We shall use PrintWindow() to draw the window.
+  // No paint events for windowed plugins.
+  if (!windowless_)
     return;
-  }
 
   // We got a paint before the plugin's coordinates, so there's no buffer to
   // copy from.
   if (!backing_store_canvas_.get())
     return;
 
   // Limit the damaged rectangle to whatever is contained inside the plugin
   // rectangle, as that's the rectangle that we'll bitblt to the hdc.
   gfx::Rect rect = damaged_rect.Intersect(plugin_rect_);
 
   bool background_changed = false;
   if (background_store_canvas_.get() && BackgroundChanged(hdc, rect)) {
     background_changed = true;
     HDC background_hdc =
         background_store_canvas_->getTopPlatformDevice().getBitmapDC();
     BitBlt(background_hdc, rect.x()-plugin_rect_.x(), rect.y()-plugin_rect_.y(),
         rect.width(), rect.height(), hdc, rect.x(), rect.y(), SRCCOPY);
   }
 
-  if (first_paint_ || background_changed) {
-    gfx::Rect offset_rect = rect;
-    offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
+  gfx::Rect offset_rect = rect;
+  offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
+  if (background_changed || !backing_store_painted_.Contains(offset_rect)) {
     Send(new PluginMsg_Paint(instance_id_, offset_rect));
     CopyFromTransportToBacking(offset_rect);
   }
 
-  first_paint_ = false;
   HDC backing_hdc = backing_store_canvas_->getTopPlatformDevice().getBitmapDC();
   BitBlt(hdc, rect.x(), rect.y(), rect.width(), rect.height(), backing_hdc,
       rect.x()-plugin_rect_.x(), rect.y()-plugin_rect_.y(), SRCCOPY);
 
   if (invalidate_pending_) {
     // Only send the PaintAck message if this paint is in response to an 
     // invalidate from the plugin, since this message acts as an access token
     // to ensure only one process is using the transport dib at a time.
     invalidate_pending_ = false;
     Send(new PluginMsg_DidPaint(instance_id_));
@@ skipping 224 matching lines @@
   return;
 }
 
 void WebPluginDelegateProxy::CopyFromTransportToBacking(const gfx::Rect& rect) {
   if (!backing_store_canvas_.get())
     return;
 
   // Copy the damaged rect from the transport bitmap to the backing store.
   HDC backing = backing_store_canvas_->getTopPlatformDevice().getBitmapDC();
   HDC transport = transport_store_canvas_->getTopPlatformDevice().getBitmapDC();
-
   BitBlt(backing, rect.x(), rect.y(), rect.width(), rect.height(),
       transport, rect.x(), rect.y(), SRCCOPY);
+  backing_store_painted_ = backing_store_painted_.Union(rect);
 }
 
 void WebPluginDelegateProxy::OnHandleURLRequest(
     const PluginHostMsg_URLRequest_Params& params) {
   const char* data = NULL;
   if (params.buffer.size())
     data = &params.buffer[0];
 
   const char* target = NULL;
   if (params.target.length())
@@ skipping 27 matching lines @@
   plugin_->CancelDocumentLoad();
 }
 
 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
    const std::string& url, const std::string& range_info,
    HANDLE existing_stream, bool notify_needed, HANDLE notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }