Fix painting problem with transparent plugins because plugins were ignoring t...

chrome/renderer/webplugin_delegate_proxy.h

 // 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.
 
 #ifndef CHROME_RENDERER_WEBPLUGIN_DELEGATE_PROXY_H__
 #define CHROME_RENDERER_WEBPLUGIN_DELEGATE_PROXY_H__
 
 #include <set>
 #include <string>
 
@@ skipping 42 matching lines @@
                           WebPlugin* plugin, bool load_manually);
   virtual void UpdateGeometry(const gfx::Rect& window_rect,
                               const gfx::Rect& clip_rect, bool visible);
   virtual void Paint(HDC hdc, const gfx::Rect& rect);
   virtual void Print(HDC hdc);
   virtual NPObject* GetPluginScriptableObject();
   virtual void DidFinishLoadWithReason(NPReason reason);
   virtual void SetFocus();
   virtual bool HandleEvent(NPEvent* event, WebCursor* cursor);
   virtual int GetProcessId();
-  virtual HWND GetWindowHandle();
 
   // IPC::Channel::Listener implementation:
   virtual void OnMessageReceived(const IPC::Message& msg);
   void OnChannelError();
 
   // IPC::Message::Sender implementation:
   virtual bool Send(IPC::Message* msg);
 
   virtual void SendJavaScriptStream(const std::string& url,
                                     const std::wstring& result,
@@ skipping 29 matching lines @@
                          const std::string& clsid,
                          RenderView* render_view);
 
   // Message handlers for messages that proxy WebPlugin methods, which
   // we translate into calls to the real WebPlugin.
   void OnSetWindow(HWND window, HANDLE modal_loop_pump_messages_event);
   void OnCompleteURL(const std::string& url_in, std::string* url_out,
                      bool* result);
   void OnHandleURLRequest(const PluginHostMsg_URLRequest_Params& params);
   void OnCancelResource(int id);
-  void OnInvalidate();
   void OnInvalidateRect(const gfx::Rect& rect);
   void OnGetWindowScriptNPObject(int route_id, bool* success, void** npobject_ptr);
   void OnGetPluginElement(int route_id, bool* success, void** npobject_ptr);
   void OnSetCookie(const GURL& url,
                    const GURL& policy_url,
                    const std::string& cookie);
   void OnGetCookies(const GURL& url, const GURL& policy_url,
                     std::string* cookies);
   void OnShowModalHTMLDialog(const GURL& url, int width, int height,
                              const std::string& json_arguments,
                              std::string* json_retval);
   void OnMissingPluginStatus(int status);
   void OnGetCPBrowsingContext(uint32* context);
   void OnCancelDocumentLoad();
   void OnInitiateHTTPRangeRequest(const std::string& url,
                                   const std::string& range_info,
                                   HANDLE existing_stream, bool notify_needed,
                                   HANDLE notify_data);
 
   // Draw a graphic indicating a crashed plugin.
   void PaintSadPlugin(HDC hdc, const gfx::Rect& rect);
 
+  // Returns true if the given rectangle is different in the hdc and the
+  // current background bitmap.
+  bool BackgroundChanged(HDC hdc, const gfx::Rect& rect);
+
+  // Copies the given rectangle from the transport bitmap to the backing store.
+  void CopyFromTransportToBacking(const gfx::Rect& rect);
+
+  // Clears the shared memory section and canvases used for windowless plugins.
+  void ResetWindowlessBitmaps();
+
+  // Creates a shared memory section and canvas.
+  bool CreateBitmap(scoped_ptr<SharedMemory>* memory,
+                    scoped_ptr<gfx::PlatformCanvasWin>* canvas);
+
   RenderView* render_view_;
   WebPlugin* plugin_;
   bool windowless_;
   bool first_paint_;
   scoped_refptr<PluginChannelHost> channel_host_;
   std::string mime_type_;
   std::string clsid_;
   int instance_id_;
   std::wstring plugin_path_;
 
   gfx::Rect plugin_rect_;
   gfx::Rect deferred_clip_rect_;
   bool send_deferred_update_geometry_;
   bool visible_;
 
   NPObject* npobject_;
   NPObjectStub* window_script_object_;
 
   // Event passed in by the plugin process and is used to decide if
   // messages need to be pumped in the NPP_HandleEvent sync call.
   ScopedHandle modal_loop_pump_messages_event_;
 
   // Bitmap for crashed plugin
   SkBitmap* sad_plugin_;
 
-  // Used for desynchronized windowless painting.  See the comment in
-  // webplugin_proxy.h for information about how this works.
-  scoped_ptr<SharedMemory> windowless_buffer_;
-  scoped_ptr<gfx::PlatformCanvasWin> windowless_canvas_;
-  ScopedHandle windowless_buffer_lock_;
+  // True if we got an invalidate from the plugin and are waiting for a paint.
+  bool invalidate_pending_;
+
+  // Used to desynchronize windowless painting.  When WebKit paints, we bitblt
+  // from our backing store of what the plugin rectangle looks like.  The
+  // plugin paints into the transport store, and we copy that to our backing
+  // store when we get an invalidate from it.  The background bitmap is used
+  // for transparent plugins, as they need the backgroud data during painting.
+  bool transparent_;
+  scoped_ptr<SharedMemory> backing_store_;
+  scoped_ptr<gfx::PlatformCanvasWin> backing_store_canvas_;
+  scoped_ptr<SharedMemory> transport_store_;
+  scoped_ptr<gfx::PlatformCanvasWin> transport_store_canvas_;
+  scoped_ptr<SharedMemory> background_store_;
+  scoped_ptr<gfx::PlatformCanvasWin> background_store_canvas_;
 
   DISALLOW_EVIL_CONSTRUCTORS(WebPluginDelegateProxy);
 };
 
 #endif  // #ifndef CHROME_RENDERER_WEBPLUGIN_DELEGATE_PROXY_H__