Improve scrolling performance when there are many windowed plugins in a page....

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/scoped_handle.h"
 #include "base/shared_memory.h"
 #include "base/singleton.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/win_util.h"
-#include "chrome/plugin/plugin_channel.h"
-#include "chrome/plugin/webplugin_delegate_stub.h"
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_util.h"
+#include "chrome/plugin/plugin_channel.h"
+#include "chrome/plugin/plugin_thread.h"
+#include "chrome/plugin/webplugin_delegate_stub.h"
 #include "skia/ext/platform_device.h"
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 
 typedef std::map<CPBrowsingContext, WebPluginProxy*> ContextMap;
 static ContextMap& GetContextMap() {
   return *Singleton<ContextMap>::get();
 }
 
 WebPluginProxy::WebPluginProxy(
     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),
 #pragma warning(suppress: 4355)  // can use this
-      runnable_method_factory_(this) {
+      runnable_method_factory_(this),
+      parent_window_(NULL) {
 
   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.";
   modal_dialog_event_.Set(event);
 }
 
 WebPluginProxy::~WebPluginProxy() {
   if (cp_browsing_context_)
     GetContextMap().erase(cp_browsing_context_);
+
+  if (parent_window_) {
+    PluginThread::GetPluginThread()->Send(
+        new PluginProcessHostMsg_DestroyWindow(parent_window_));
+  }
 }
 
 bool WebPluginProxy::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
 
 void WebPluginProxy::SetWindow(HWND window, HANDLE pump_messages_event) {
   HANDLE pump_messages_event_for_renderer = NULL;
 
   if (pump_messages_event) {
     DCHECK(window == NULL);
     DuplicateHandle(GetCurrentProcess(), pump_messages_event,
                     channel_->renderer_handle(),
                     &pump_messages_event_for_renderer,
                     0, FALSE, DUPLICATE_SAME_ACCESS);
     DCHECK(pump_messages_event_for_renderer != NULL);
+  } else {
+    DCHECK (window);
+    // To make scrolling windowed plugins fast, we create the page's direct
+    // child windows in the browser process.  This way no cross process messages
+    // are sent.
+    HWND old_parent = GetParent(window);
+    IPC::SyncMessage* msg = new PluginProcessHostMsg_CreateWindow(
+        old_parent, &parent_window_);
+
+    // Need to process window messages in the meantime to avoid a deadlock if
+    // the browser paints or sends any other (synchronous) WM_ message to the
+    // plugin window.
+    msg->EnableMessagePumping();
+    PluginThread::GetPluginThread()->Send(msg);
+
+    SetParent(window, parent_window_);
+
+    // We want the browser process to move this window which has a message loop
+    // in its process.
+    window = parent_window_;
   }
 
   Send(new PluginHostMsg_SetWindow(route_id_, window,
                                    pump_messages_event_for_renderer));
 }
 
 void WebPluginProxy::CancelResource(int id) {
   Send(new PluginHostMsg_CancelResource(route_id_, id));
   resource_clients_.erase(id);
 }
@@ skipping 191 matching lines @@
   }
 
   // Before we send the invalidate, paint so that renderer uses the updated
   // bitmap.
   delegate_->Paint(windowless_hdc_, offset_rect);
 }
 
 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);
+  delegate_->UpdateGeometry(window_rect, clip_rect);
   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() &&
+  if (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.
@@ skipping 72 matching lines @@
 
   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));
 }