Implement "iframe shim" behavior for windowed plugins....

webkit/glue/webplugin_impl.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 "config.h"
 
 #pragma warning(push, 0)
 #include "Document.h"
 #include "Element.h"
 #include "Event.h"
 #include "EventNames.h"
 #include "FormData.h"
 #include "FocusController.h"
 #include "Frame.h"
 #include "FrameLoader.h"
 #include "FrameLoadRequest.h"
 #include "FrameTree.h"
 #include "FrameView.h"
 #include "GraphicsContext.h"
+#include "HTMLNames.h"
 #include "HTMLPluginElement.h"
 #include "IntRect.h"
 #include "KURL.h"
 #include "KeyboardEvent.h"
 #include "MouseEvent.h"
 #include "Page.h"
 #include "PlatformMouseEvent.h"
 #include "PlatformString.h"
 #include "ResourceHandle.h"
 #include "ResourceHandleClient.h"
 #include "ResourceResponse.h"
 #include "ScriptController.h"
 #include "ScrollView.h"
 #include "Widget.h"
 #pragma warning(pop)
 #undef LOG
 
 #include "base/gfx/rect.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "net/base/escape.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/multipart_response_delegate.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webplugin_impl.h"
 #include "webkit/glue/plugins/plugin_host.h"
 #include "webkit/glue/plugins/plugin_instance.h"
+#include "webkit/glue/stacking_order_iterator.h"
 #include "webkit/glue/webview_impl.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/port/platform/cursor.h"
 
 // This class handles invididual multipart responses. It is instantiated when
 // we receive HTTP status code 206 in the HTTP response. This indicates
 // that the response could have multiple parts each separated by a boundary
 // specified in the response header.
 class MultiPartResponseClient : public WebCore::ResourceHandleClient {
  public:
@@ skipping 113 matching lines @@
 void WebPluginContainer::attachToWindow() {
   Widget::attachToWindow();
   show();
 }
 
 void WebPluginContainer::detachFromWindow() {
   Widget::detachFromWindow();
   hide();
 }
 
+void WebPluginContainer::windowCutoutRects(WTF::Vector<WebCore::IntRect>*
+                                           cutouts) const {
+  impl_->windowCutoutRects(cutouts);
+}
+
 void WebPluginContainer::didReceiveResponse(
     const WebCore::ResourceResponse& response) {
   
   HttpResponseInfo http_response_info;
   ReadHttpResponseInfo(response, &http_response_info);
 
   impl_->delegate_->DidReceiveManualResponse(
       http_response_info.url, 
       base::SysWideToNativeMB(http_response_info.mime_type),
       base::SysWideToNativeMB(impl_->GetAllHeaders(response)),
@@ skipping 331 matching lines @@
   // document()->renderer() can be NULL when we receive messages from the
   // plugins while we are destroying a frame.
   if (element_->renderer()->document()->renderer()) {
     WebCore::FrameView* parent_view = element_->document()->view();
     clip_rect.intersect(parent_view->windowClipRectForLayer(layer, true));
   }
 
   return clip_rect;
 }
 
+void WebPluginImpl::windowCutoutRects(
+    WTF::Vector<WebCore::IntRect>* cutouts) const {
+  WebCore::RenderObject* plugin_node = element_->renderer();
+  ASSERT(plugin_node);
+
+  // Find all iframes that stack higher than this plugin.
+  bool higher = false;
+  StackingOrderIterator iterator;
+  WebCore::RenderLayer* root = element_->document()->renderer()->
+                               enclosingLayer();
+  iterator.Reset(root);
+
+  while (WebCore::RenderObject* ro = iterator.Next()) {
+    if (ro == plugin_node) {
+      // All nodes after this one are higher than plugin.
+      higher = true;
+    } else if (higher) {
+      // Is this a visible iframe?
+      WebCore::Node* n = ro->node();
+      if (n && n->hasTagName(WebCore::HTMLNames::iframeTag)) {
+        if (!ro->style() || ro->style()->visibility() == WebCore::VISIBLE) {
+          int x, y;
+          ro->absolutePosition(x, y);
+          cutouts->append(WebCore::IntRect(x, y, ro->width(), ro->height()));
+        }
+      }
+    }
+  }
+}
+
 void WebPluginImpl::geometryChanged() const {
   if (!widget_)
     return;
 
   // This is a hack to tickle re-positioning of the plugin in the case where
   // our parent view was scrolled.
   const_cast<WebPluginImpl*>(this)->widget_->setFrameGeometry(
       widget_->frameGeometry());
-  }
+}
 
 void WebPluginImpl::setFrameGeometry(const WebCore::IntRect& rect) {
   // Compute a new position and clip rect for ourselves relative to the
   // containing window.  We ask our delegate to reposition us accordingly.
 
   // When the plugin is loaded we don't have a parent frame yet. We need
   // to force the plugin window to get created in the plugin process,
   // when the plugin widget position is updated. This occurs just after
   // the plugin is loaded (See http://b/issue?id=892174).
   if (!parent()) {
     force_geometry_update_ = true;
     return;
   }
 
   WebCore::Frame* frame = element_->document()->frame();
   WebFrameImpl* webframe = WebFrameImpl::FromFrame(frame);
   WebViewImpl* webview = webframe->webview_impl();
   // It is valid for this function to be invoked in code paths where the
   // the webview is closed.
   if (!webview->delegate()) {
     return;
   }
 
   WebCore::IntRect window_rect;
   WebCore::IntRect clip_rect;
-  CalculateBounds(rect, &window_rect, &clip_rect);
+  std::vector<gfx::Rect> cutout_rects;
+  CalculateBounds(rect, &window_rect, &clip_rect, &cutout_rects);
 
   if (window_ && received_first_paint_notification_) {
     // Let the WebViewDelegate know that the plugin window needs to be moved,
     // so that all the HWNDs are moved together.
     WebPluginGeometry move;
     move.window = window_;
     move.window_rect = gfx::Rect(window_rect);
     move.clip_rect = gfx::Rect(clip_rect);
+    move.cutout_rects = cutout_rects;
     move.visible = visible_;
+
     webview->delegate()->DidMove(webview, move);
   }
 
   delegate_->UpdateGeometry(
-      gfx::Rect(window_rect), gfx::Rect(clip_rect),
+      gfx::Rect(window_rect), gfx::Rect(clip_rect), cutout_rects,
       received_first_paint_notification_? visible_ : false);
 
   // delegate_ can go away as a result of above call, so check it first.
   if (force_geometry_update_ && delegate_) {
     force_geometry_update_ = false;
     delegate_->FlushGeometryUpdates();
   }
 }
 
 void WebPluginImpl::paint(WebCore::GraphicsContext* gc,
@@ skipping 14 matching lines @@
   // it becomes visible.
   // Please refer to https://bugs.webkit.org/show_bug.cgi?id=18901 for more
   // details on this issue.
   // TODO(iyengar): Remove this hack when this issue is fixed in webkit.
   if (!received_first_paint_notification_) {
     received_first_paint_notification_ = true;
 
     if (!windowless_) {
       WebCore::IntRect window_rect;
       WebCore::IntRect clip_rect;
+      std::vector<gfx::Rect> cutout_rects;
 
-      CalculateBounds(widget_->frameGeometry(), &window_rect, &clip_rect);
+      CalculateBounds(widget_->frameGeometry(), &window_rect, &clip_rect,
+                      &cutout_rects);
 
       delegate_->UpdateGeometry(gfx::Rect(window_rect), gfx::Rect(clip_rect),
-                                visible_);
+                                cutout_rects, visible_);
       delegate_->FlushGeometryUpdates();
     }
   }
 
   gc->save();
 
   DCHECK(parent()->isFrameView());
   WebCore::FrameView* view = static_cast<WebCore::FrameView*>(parent());
 
   // The plugin is positioned in window coordinates, so it needs to be painted
@@ skipping 359 matching lines @@
 
 WebCore::ScrollView* WebPluginImpl::parent() const {
   if (widget_)
     return widget_->parent();
 
   return NULL;
 }
 
 void WebPluginImpl::CalculateBounds(const WebCore::IntRect& frame_rect,
                                     WebCore::IntRect* window_rect,
-                                    WebCore::IntRect* clip_rect) {
+                                    WebCore::IntRect* clip_rect,
+                                    std::vector<gfx::Rect>* cutout_rects) {
   DCHECK(parent()->isFrameView());
   WebCore::FrameView* view = static_cast<WebCore::FrameView*>(parent());
 
   *window_rect =
       WebCore::IntRect(view->contentsToWindow(frame_rect.location()),
                                               frame_rect.size());
   // Calculate a clip-rect so that we don't overlap the scrollbars, etc.
   *clip_rect = widget_->windowClipRect();
   clip_rect->move(-window_rect->x(), -window_rect->y());
+
+  cutout_rects->clear();
+  WTF::Vector<WebCore::IntRect> rects;
+  widget_->windowCutoutRects(&rects);
+  // Convert to gfx::Rect and subtract out the plugin position.
+  for (size_t i = 0; i < rects.size(); i++) {
+    gfx::Rect r(rects[i]);
+    r.Offset(-frame_rect.x(), -frame_rect.y());
+    cutout_rects->push_back(r);
+  }
 }
 
 void WebPluginImpl::HandleURLRequest(const char *method,
                                      bool is_javascript_url,
                                      const char* target, unsigned int len,
                                      const char* buf, bool is_file_data,
                                      bool notify, const char* url,
                                      void* notify_data, bool popups_allowed) {
   // For this request, we either route the output to a frame
   // because a target has been specified, or we handle the request
@@ skipping 139 matching lines @@
 
   MultiPartResponseClient* multi_part_response_client =
       new MultiPartResponseClient(client);
 
   MultipartResponseDelegate* multi_part_response_handler = 
       new MultipartResponseDelegate(multi_part_response_client, NULL, 
                                     response, 
                                     multipart_boundary);
   multi_part_response_map_[client] = multi_part_response_handler;
 }