Source/WebCore/plugins/qt/PluginViewQt.cpp

   1 /*
   2  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
   3  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
   4  * Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "config.h"
  29 #include "PluginView.h"
  30
  31 #if USE(JSC)
  32 #include "BridgeJSC.h"
  33 #endif
  34 #include "Chrome.h"
  35 #include "ChromeClient.h"
  36 #include "Document.h"
  37 #include "DocumentLoader.h"
  38 #include "Element.h"
  39 #include "FloatPoint.h"
  40 #include "FocusController.h"
  41 #include "Frame.h"
  42 #include "FrameLoadRequest.h"
  43 #include "FrameLoader.h"
  44 #include "FrameTree.h"
  45 #include "FrameView.h"
  46 #include "GraphicsContext.h"
  47 #include "HTMLNames.h"
  48 #include "HTMLPlugInElement.h"
  49 #include "HostWindow.h"
  50 #include "IFrameShimSupport.h"
  51 #include "Image.h"
  52 #if USE(JSC)
  53 #include "JSDOMBinding.h"
  54 #endif
  55 #include "KeyboardEvent.h"
  56 #include "MouseEvent.h"
  57 #include "NotImplemented.h"
  58 #include "Page.h"
  59 #include "PlatformMouseEvent.h"
  60 #include "PlatformKeyboardEvent.h"
  61 #include "PluginContainerQt.h"
  62 #include "PluginDebug.h"
  63 #include "PluginPackage.h"
  64 #include "PluginMainThreadScheduler.h"
  65 #include "QWebPageClient.h"
  66 #include "RenderLayer.h"
  67 #include "Settings.h"
  68 #include "npruntime_impl.h"
  69 #if USE(JSC)
  70 #include "runtime_root.h"
  71 #endif
  72
  73 #include <QApplication>
  74 #include <QDesktopWidget>
  75 #include <QGraphicsWidget>
  76 #include <QKeyEvent>
  77 #include <QPainter>
  78 #include <QStyleOptionGraphicsItem>
  79 #include <QWidget>
  80 #include <QX11Info>
  81 #include <X11/X.h>
  82 #ifndef QT_NO_XRENDER
  83 #define Bool int
  84 #define Status int
  85 #include <X11/extensions/Xrender.h>
  86 #endif
  87 #include <runtime/JSLock.h>
  88 #include <runtime/JSValue.h>
  89
  90 using JSC::ExecState;
  91 #if USE(JSC)
  92 using JSC::Interpreter;
  93 #endif
  94 using JSC::JSLock;
  95 using JSC::JSObject;
  96 using JSC::UString;
  97
  98 using std::min;
  99
 100 using namespace WTF;
 101
 102 namespace WebCore {
 103
 104 bool PluginView::s_isRunningUnderDRT = false;
 105
 106 using namespace HTMLNames;
 107
 108 #if USE(ACCELERATED_COMPOSITING)
 109 // Qt's GraphicsLayer (GraphicsLayerQt) requires layers to be QGraphicsWidgets
 110 class PluginGraphicsLayerQt : public QGraphicsWidget {
 111 public:
 112     PluginGraphicsLayerQt(PluginView* view) : m_view(view) { }
 113     ~PluginGraphicsLayerQt() { }
 114
 115     void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0)
 116     {
 117         Q_UNUSED(widget);
 118         m_view->paintUsingXPixmap(painter, option->exposedRect.toRect());
 119     }
 120
 121 private:
 122     PluginView* m_view;
 123 };
 124
 125 bool PluginView::shouldUseAcceleratedCompositing() const
 126 {
 127     return m_parentFrame->page()->chrome()->client()->allowsAcceleratedCompositing()
 128            && m_parentFrame->page()->settings()
 129            && m_parentFrame->page()->settings()->acceleratedCompositingEnabled();
 130 }
 131 #endif
 132
 133 void PluginView::updatePluginWidget()
 134 {
 135     if (!parent())
 136         return;
 137
 138     ASSERT(parent()->isFrameView());
 139     FrameView* frameView = static_cast<FrameView*>(parent());
 140
 141     IntRect oldWindowRect = m_windowRect;
 142     IntRect oldClipRect = m_clipRect;
 143
 144     m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
 145     m_clipRect = windowClipRect();
 146     m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
 147
 148     if (m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
 149         return;
 150
 151     // The plugin had a zero width or height before but was resized, we need to show it again.
 152     if (oldWindowRect.isEmpty())
 153         show();
 154
 155     if (!m_isWindowed && m_windowRect.size() != oldWindowRect.size()) {
 156         if (m_drawable)
 157             XFreePixmap(QX11Info::display(), m_drawable);
 158
 159         m_drawable = XCreatePixmap(QX11Info::display(), QX11Info::appRootWindow(), m_windowRect.width(), m_windowRect.height(),
 160                                    ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
 161         QApplication::syncX(); // make sure that the server knows about the Drawable
 162     }
 163
 164     // do not call setNPWindowIfNeeded immediately, will be called on paint()
 165     m_hasPendingGeometryChange = true;
 166
 167     // (i) in order to move/resize the plugin window at the same time as the
 168     // rest of frame during e.g. scrolling, we set the window geometry
 169     // in the paint() function, but as paint() isn't called when the
 170     // plugin window is outside the frame which can be caused by a
 171     // scroll, we need to move/resize immediately.
 172     // (ii) if we are running layout tests from DRT, paint() won't ever get called
 173     // so we need to call setNPWindowIfNeeded() if window geometry has changed
 174     if (!m_windowRect.intersects(frameView->frameRect())
 175         || (s_isRunningUnderDRT && platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)))
 176         setNPWindowIfNeeded();
 177
 178     if (!m_platformLayer) {
 179         // Make sure we get repainted afterwards. This is necessary for downward
 180         // scrolling to move the plugin widget properly.
 181         // Note that we don't invalidate the frameRect() here. This is because QWebFrame::renderRelativeCoords()
 182         // imitates ScrollView and adds the scroll offset back on to the rect we damage here (making the co-ordinates absolute
 183         // to the frame again) before passing it to FrameView.
 184         invalidate();
 185     }
 186 }
 187
 188 void PluginView::setFocus(bool focused)
 189 {
 190     if (platformPluginWidget()) {
 191         if (focused)
 192             static_cast<QWidget*>(platformPluginWidget())->setFocus(Qt::OtherFocusReason);
 193     } else {
 194         Widget::setFocus(focused);
 195     }
 196 }
 197
 198 void PluginView::show()
 199 {
 200     Q_ASSERT(platformPluginWidget() == platformWidget());
 201     Widget::show();
 202 }
 203
 204 void PluginView::hide()
 205 {
 206     Q_ASSERT(platformPluginWidget() == platformWidget());
 207     Widget::hide();
 208 }
 209
 210 void PluginView::paintUsingXPixmap(QPainter* painter, const QRect &exposedRect)
 211 {
 212     QPixmap qtDrawable = QPixmap::fromX11Pixmap(m_drawable, QPixmap::ExplicitlyShared);
 213     const int drawableDepth = ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth;
 214     ASSERT(drawableDepth == qtDrawable.depth());
 215     const bool syncX = m_pluginDisplay && m_pluginDisplay != QX11Info::display();
 216
 217     // When printing, Qt uses a QPicture to capture the output in preview mode. The
 218     // QPicture holds a reference to the X Pixmap. As a result, the print preview would
 219     // update itself when the X Pixmap changes. To prevent this, we create a copy.
 220     if (m_element->document()->printing())
 221         qtDrawable = qtDrawable.copy();
 222
 223     if (m_isTransparent && drawableDepth != 32) {
 224         // Attempt content propagation for drawable with no alpha by copying over from the backing store
 225         QPoint offset;
 226         QPaintDevice* backingStoreDevice =  QPainter::redirected(painter->device(), &offset);
 227         offset = -offset; // negating the offset gives us the offset of the view within the backing store pixmap
 228
 229         const bool hasValidBackingStore = backingStoreDevice && backingStoreDevice->devType() == QInternal::Pixmap;
 230         QPixmap* backingStorePixmap = static_cast<QPixmap*>(backingStoreDevice);
 231
 232         // We cannot grab contents from the backing store when painting on QGraphicsView items
 233         // (because backing store contents are already transformed). What we really mean to do
 234         // here is to check if we are painting on QWebView, but let's be a little permissive :)
 235         QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
 236         const bool backingStoreHasUntransformedContents = client && qobject_cast<QWidget*>(client->pluginParent());
 237
 238         if (hasValidBackingStore && backingStorePixmap->depth() == drawableDepth
 239             && backingStoreHasUntransformedContents) {
 240             GC gc = XDefaultGC(QX11Info::display(), QX11Info::appScreen());
 241             XCopyArea(QX11Info::display(), backingStorePixmap->handle(), m_drawable, gc,
 242                 offset.x() + m_windowRect.x() + exposedRect.x(), offset.y() + m_windowRect.y() + exposedRect.y(),
 243                 exposedRect.width(), exposedRect.height(), exposedRect.x(), exposedRect.y());
 244         } else { // no backing store, clean the pixmap because the plugin thinks its transparent
 245             QPainter painter(&qtDrawable);
 246             painter.fillRect(exposedRect, Qt::white);
 247         }
 248
 249         if (syncX)
 250             QApplication::syncX();
 251     }
 252
 253     XEvent xevent;
 254     memset(&xevent, 0, sizeof(XEvent));
 255     XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;
 256     exposeEvent.type = GraphicsExpose;
 257     exposeEvent.display = QX11Info::display();
 258     exposeEvent.drawable = qtDrawable.handle();
 259     exposeEvent.x = exposedRect.x();
 260     exposeEvent.y = exposedRect.y();
 261     exposeEvent.width = exposedRect.x() + exposedRect.width(); // flash bug? it thinks width is the right in transparent mode
 262     exposeEvent.height = exposedRect.y() + exposedRect.height(); // flash bug? it thinks height is the bottom in transparent mode
 263
 264     dispatchNPEvent(xevent);
 265
 266     if (syncX)
 267         XSync(m_pluginDisplay, false); // sync changes by plugin
 268
 269     painter->drawPixmap(QPoint(exposedRect.x(), exposedRect.y()), qtDrawable, exposedRect);
 270 }
 271
 272 void PluginView::paint(GraphicsContext* context, const IntRect& rect)
 273 {
 274     if (!m_isStarted) {
 275         paintMissingPluginIcon(context, rect);
 276         return;
 277     }
 278
 279     if (context->paintingDisabled())
 280         return;
 281
 282     setNPWindowIfNeeded();
 283
 284     if (m_isWindowed)
 285         return;
 286
 287 #if USE(ACCELERATED_COMPOSITING)
 288     if (m_platformLayer)
 289         return;
 290 #endif
 291
 292     if (!m_drawable)
 293         return;
 294
 295     QPainter* painter = context->platformContext();
 296     IntRect exposedRect(rect);
 297     exposedRect.intersect(frameRect());
 298     exposedRect.move(-frameRect().x(), -frameRect().y());
 299
 300     painter->translate(frameRect().x(), frameRect().y());
 301     paintUsingXPixmap(painter, exposedRect);
 302     painter->translate(-frameRect().x(), -frameRect().y());
 303 }
 304
 305 // TODO: Unify across ports.
 306 bool PluginView::dispatchNPEvent(NPEvent& event)
 307 {
 308     if (!m_plugin->pluginFuncs()->event)
 309         return false;
 310
 311     bool shouldPop = false;
 312
 313     if (m_plugin->pluginFuncs()->version < NPVERS_HAS_POPUPS_ENABLED_STATE
 314         && (event.type == ButtonRelease || event.type == 3 /*KeyRelease*/)) {
 315         pushPopupsEnabledState(true);
 316         shouldPop = true;
 317     }
 318
 319     PluginView::setCurrentPluginView(this);
 320 #if USE(JSC)
 321     JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);
 322 #endif
 323     setCallingPlugin(true);
 324     bool accepted = !m_plugin->pluginFuncs()->event(m_instance, &event);
 325     setCallingPlugin(false);
 326     PluginView::setCurrentPluginView(0);
 327
 328     if (shouldPop)
 329         popPopupsEnabledState();
 330
 331     return accepted;
 332 }
 333
 334 void setSharedXEventFields(XEvent* xEvent, QWidget* ownerWidget)
 335 {
 336     xEvent->xany.serial = 0; // we are unaware of the last request processed by X Server
 337     xEvent->xany.send_event = false;
 338     xEvent->xany.display = QX11Info::display();
 339     // NOTE: event->xany.window doesn't always respond to the .window property of other XEvent's
 340     // but does in the case of KeyPress, KeyRelease, ButtonPress, ButtonRelease, and MotionNotify
 341     // events; thus, this is right:
 342     xEvent->xany.window = ownerWidget ? ownerWidget->window()->handle() : 0;
 343 }
 344
 345 void PluginView::initXEvent(XEvent* xEvent)
 346 {
 347     memset(xEvent, 0, sizeof(XEvent));
 348
 349     QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
 350     QWidget* ownerWidget = client ? client->ownerWidget() : 0;
 351     setSharedXEventFields(xEvent, ownerWidget);
 352 }
 353
 354 void PluginView::setXKeyEventSpecificFields(XEvent* xEvent, KeyboardEvent* event)
 355 {
 356     const PlatformKeyboardEvent* keyEvent = event->keyEvent();
 357
 358     xEvent->type = (event->type() == eventNames().keydownEvent) ? 2 : 3; // ints as Qt unsets KeyPress and KeyRelease
 359     xEvent->xkey.root = QX11Info::appRootWindow();
 360     xEvent->xkey.subwindow = 0; // we have no child window
 361     xEvent->xkey.time = event->timeStamp();
 362     xEvent->xkey.state = keyEvent->nativeModifiers();
 363     xEvent->xkey.keycode = keyEvent->nativeScanCode();
 364
 365     // We may not have a nativeScanCode() if the key event is from DRT's eventsender. In that
 366     // case fetch the XEvent's keycode from the event's text. The only
 367     // place this keycode will be used is in webkit_test_plugin_handle_event().
 368     // FIXME: Create Qt API so that we can set the appropriate keycode in DRT EventSender instead.
 369     if (s_isRunningUnderDRT && !xEvent->xkey.keycode) {
 370         QKeyEvent* qKeyEvent = keyEvent->qtEvent();
 371         ASSERT(qKeyEvent);
 372         QString keyText = qKeyEvent->text().left(1);
 373         xEvent->xkey.keycode = XKeysymToKeycode(QX11Info::display(), XStringToKeysym(keyText.toUtf8().constData()));
 374     }
 375
 376     xEvent->xkey.same_screen = true;
 377
 378     // NOTE: As the XEvents sent to the plug-in are synthesized and there is not a native window
 379     // corresponding to the plug-in rectangle, some of the members of the XEvent structures are not
 380     // set to their normal Xserver values. e.g. Key events don't have a position.
 381     // source: https://developer.mozilla.org/en/NPEvent
 382     xEvent->xkey.x = 0;
 383     xEvent->xkey.y = 0;
 384     xEvent->xkey.x_root = 0;
 385     xEvent->xkey.y_root = 0;
 386 }
 387
 388 void PluginView::handleKeyboardEvent(KeyboardEvent* event)
 389 {
 390     if (m_isWindowed)
 391         return;
 392
 393     if (event->type() != eventNames().keydownEvent && event->type() != eventNames().keyupEvent)
 394         return;
 395
 396     XEvent npEvent;
 397     initXEvent(&npEvent);
 398     setXKeyEventSpecificFields(&npEvent, event);
 399
 400     if (dispatchNPEvent(npEvent))
 401         event->setDefaultHandled();
 402 }
 403
 404 static unsigned int inputEventState(MouseEvent* event)
 405 {
 406     unsigned int state = 0;
 407     if (event->ctrlKey())
 408         state |= ControlMask;
 409     if (event->shiftKey())
 410         state |= ShiftMask;
 411     if (event->altKey())
 412         state |= Mod1Mask;
 413     if (event->metaKey())
 414         state |= Mod4Mask;
 415     return state;
 416 }
 417
 418 static void setXButtonEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos)
 419 {
 420     XButtonEvent& xbutton = xEvent->xbutton;
 421     xbutton.type = event->type() == eventNames().mousedownEvent ? ButtonPress : ButtonRelease;
 422     xbutton.root = QX11Info::appRootWindow();
 423     xbutton.subwindow = 0;
 424     xbutton.time = event->timeStamp();
 425     xbutton.x = postZoomPos.x();
 426     xbutton.y = postZoomPos.y();
 427     xbutton.x_root = event->screenX();
 428     xbutton.y_root = event->screenY();
 429     xbutton.state = inputEventState(event);
 430     switch (event->button()) {
 431     case MiddleButton:
 432         xbutton.button = Button2;
 433         break;
 434     case RightButton:
 435         xbutton.button = Button3;
 436         break;
 437     case LeftButton:
 438     default:
 439         xbutton.button = Button1;
 440         break;
 441     }
 442     xbutton.same_screen = true;
 443 }
 444
 445 static void setXMotionEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos)
 446 {
 447     XMotionEvent& xmotion = xEvent->xmotion;
 448     xmotion.type = MotionNotify;
 449     xmotion.root = QX11Info::appRootWindow();
 450     xmotion.subwindow = 0;
 451     xmotion.time = event->timeStamp();
 452     xmotion.x = postZoomPos.x();
 453     xmotion.y = postZoomPos.y();
 454     xmotion.x_root = event->screenX();
 455     xmotion.y_root = event->screenY();
 456     xmotion.state = inputEventState(event);
 457     xmotion.is_hint = NotifyNormal;
 458     xmotion.same_screen = true;
 459 }
 460
 461 static void setXCrossingEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos)
 462 {
 463     XCrossingEvent& xcrossing = xEvent->xcrossing;
 464     xcrossing.type = event->type() == eventNames().mouseoverEvent ? EnterNotify : LeaveNotify;
 465     xcrossing.root = QX11Info::appRootWindow();
 466     xcrossing.subwindow = 0;
 467     xcrossing.time = event->timeStamp();
 468     xcrossing.x = postZoomPos.y();
 469     xcrossing.y = postZoomPos.x();
 470     xcrossing.x_root = event->screenX();
 471     xcrossing.y_root = event->screenY();
 472     xcrossing.state = inputEventState(event);
 473     xcrossing.mode = NotifyNormal;
 474     xcrossing.detail = NotifyDetailNone;
 475     xcrossing.same_screen = true;
 476     xcrossing.focus = false;
 477 }
 478
 479 void PluginView::handleMouseEvent(MouseEvent* event)
 480 {
 481     if (m_isWindowed)
 482         return;
 483
 484     if (event->button() == RightButton && m_plugin->quirks().contains(PluginQuirkIgnoreRightClickInWindowlessMode))
 485         return;
 486
 487     if (event->type() == eventNames().mousedownEvent) {
 488         // Give focus to the plugin on click
 489         if (Page* page = m_parentFrame->page())
 490             page->focusController()->setActive(true);
 491
 492         focusPluginElement();
 493     }
 494
 495     XEvent npEvent;
 496     initXEvent(&npEvent);
 497
 498     IntPoint postZoomPos = roundedIntPoint(m_element->renderer()->absoluteToLocal(event->absoluteLocation()));
 499
 500     if (event->type() == eventNames().mousedownEvent || event->type() == eventNames().mouseupEvent)
 501         setXButtonEventSpecificFields(&npEvent, event, postZoomPos);
 502     else if (event->type() == eventNames().mousemoveEvent)
 503         setXMotionEventSpecificFields(&npEvent, event, postZoomPos);
 504     else if (event->type() == eventNames().mouseoutEvent || event->type() == eventNames().mouseoverEvent)
 505         setXCrossingEventSpecificFields(&npEvent, event, postZoomPos);
 506     else
 507         return;
 508
 509     if (dispatchNPEvent(npEvent))
 510         event->setDefaultHandled();
 511 }
 512
 513 void PluginView::handleFocusInEvent()
 514 {
 515     XEvent npEvent;
 516     initXEvent(&npEvent);
 517
 518     XFocusChangeEvent& event = npEvent.xfocus;
 519     event.type = 9; /* int as Qt unsets FocusIn */
 520     event.mode = NotifyNormal;
 521     event.detail = NotifyDetailNone;
 522
 523     dispatchNPEvent(npEvent);
 524 }
 525
 526 void PluginView::handleFocusOutEvent()
 527 {
 528     XEvent npEvent;
 529     initXEvent(&npEvent);
 530
 531     XFocusChangeEvent& event = npEvent.xfocus;
 532     event.type = 10; /* int as Qt unsets FocusOut */
 533     event.mode = NotifyNormal;
 534     event.detail = NotifyDetailNone;
 535
 536     dispatchNPEvent(npEvent);
 537 }
 538
 539 void PluginView::setParent(ScrollView* parent)
 540 {
 541     Widget::setParent(parent);
 542
 543     if (parent)
 544         init();
 545 }
 546
 547 void PluginView::setNPWindowRect(const IntRect&)
 548 {
 549     if (!m_isWindowed)
 550         setNPWindowIfNeeded();
 551 }
 552
 553 void PluginView::setNPWindowIfNeeded()
 554 {
 555     if (!m_isStarted || !parent() || !m_plugin->pluginFuncs()->setwindow)
 556         return;
 557
 558     // If the plugin didn't load sucessfully, no point in calling setwindow
 559     if (m_status != PluginStatusLoadedSuccessfully)
 560         return;
 561
 562     // On Unix, only call plugin if it's full-page or windowed
 563     if (m_mode != NP_FULL && m_mode != NP_EMBED)
 564         return;
 565
 566     // Check if the platformPluginWidget still exists
 567     if (m_isWindowed && !platformPluginWidget())
 568         return;
 569
 570     if (!m_hasPendingGeometryChange)
 571         return;
 572     m_hasPendingGeometryChange = false;
 573
 574     if (m_isWindowed) {
 575         QWidget* widget = static_cast<QWidget*>(platformPluginWidget());
 576         widget->setGeometry(m_windowRect);
 577
 578         // Cut out areas of the plugin occluded by iframe shims
 579         Vector<IntRect> cutOutRects;
 580         QRegion clipRegion = QRegion(m_clipRect);
 581         getPluginOcclusions(m_element, this->parent(), frameRect(), cutOutRects);
 582         for (size_t i = 0; i < cutOutRects.size(); i++) {
 583             cutOutRects[i].move(-frameRect().x(), -frameRect().y());
 584             clipRegion = clipRegion.subtracted(QRegion(cutOutRects[i]));
 585         }
 586         // if setMask is set with an empty QRegion, no clipping will
 587         // be performed, so in that case we hide the plugin view
 588         widget->setVisible(!clipRegion.isEmpty());
 589         widget->setMask(clipRegion);
 590
 591         m_npWindow.x = m_windowRect.x();
 592         m_npWindow.y = m_windowRect.y();
 593     } else {
 594         m_npWindow.x = 0;
 595         m_npWindow.y = 0;
 596     }
 597
 598     // If the width or height are null, set the clipRect to null, indicating that
 599     // the plugin is not visible/scrolled out.
 600     if (!m_clipRect.width() || !m_clipRect.height()) {
 601         m_npWindow.clipRect.left = 0;
 602         m_npWindow.clipRect.right = 0;
 603         m_npWindow.clipRect.top = 0;
 604         m_npWindow.clipRect.bottom = 0;
 605     } else {
 606         // Clipping rectangle of the plug-in; the origin is the top left corner of the drawable or window.
 607         m_npWindow.clipRect.left = m_npWindow.x + m_clipRect.x();
 608         m_npWindow.clipRect.top = m_npWindow.y + m_clipRect.y();
 609         m_npWindow.clipRect.right = m_npWindow.x + m_clipRect.x() + m_clipRect.width();
 610         m_npWindow.clipRect.bottom = m_npWindow.y + m_clipRect.y() + m_clipRect.height();
 611     }
 612
 613     if (m_plugin->quirks().contains(PluginQuirkDontCallSetWindowMoreThanOnce)) {
 614         // FLASH WORKAROUND: Only set initially. Multiple calls to
 615         // setNPWindow() cause the plugin to crash in windowed mode.
 616         if (!m_isWindowed || m_npWindow.width == -1 || m_npWindow.height == -1) {
 617             m_npWindow.width = m_windowRect.width();
 618             m_npWindow.height = m_windowRect.height();
 619         }
 620     } else {
 621         m_npWindow.width = m_windowRect.width();
 622         m_npWindow.height = m_windowRect.height();
 623     }
 624
 625     PluginView::setCurrentPluginView(this);
 626 #if USE(JSC)
 627     JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);
 628 #endif
 629     setCallingPlugin(true);
 630     m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
 631     setCallingPlugin(false);
 632     PluginView::setCurrentPluginView(0);
 633 }
 634
 635 void PluginView::setParentVisible(bool visible)
 636 {
 637     if (isParentVisible() == visible)
 638         return;
 639
 640     Widget::setParentVisible(visible);
 641
 642     if (isSelfVisible() && platformPluginWidget())
 643         static_cast<QWidget*>(platformPluginWidget())->setVisible(visible);
 644 }
 645
 646 NPError PluginView::handlePostReadFile(Vector<char>& buffer, uint32_t len, const char* buf)
 647 {
 648     String filename(buf, len);
 649
 650     if (filename.startsWith("file:///"))
 651         filename = filename.substring(8);
 652
 653     long long size;
 654     if (!getFileSize(filename, size))
 655         return NPERR_FILE_NOT_FOUND;
 656
 657     FILE* fileHandle = fopen((filename.utf8()).data(), "r");
 658     if (!fileHandle)
 659         return NPERR_FILE_NOT_FOUND;
 660
 661     buffer.resize(size);
 662     int bytesRead = fread(buffer.data(), 1, size, fileHandle);
 663
 664     fclose(fileHandle);
 665
 666     if (bytesRead <= 0)
 667         return NPERR_FILE_NOT_FOUND;
 668
 669     return NPERR_NO_ERROR;
 670 }
 671
 672 bool PluginView::platformGetValueStatic(NPNVariable variable, void* value, NPError* result)
 673 {
 674     switch (variable) {
 675     case NPNVToolkit:
 676         *static_cast<uint32_t*>(value) = 0;
 677         *result = NPERR_NO_ERROR;
 678         return true;
 679
 680     case NPNVSupportsXEmbedBool:
 681         *static_cast<NPBool*>(value) = true;
 682         *result = NPERR_NO_ERROR;
 683         return true;
 684
 685     case NPNVjavascriptEnabledBool:
 686         *static_cast<NPBool*>(value) = true;
 687         *result = NPERR_NO_ERROR;
 688         return true;
 689
 690     case NPNVSupportsWindowless:
 691         *static_cast<NPBool*>(value) = true;
 692         *result = NPERR_NO_ERROR;
 693         return true;
 694
 695     default:
 696         return false;
 697     }
 698 }
 699
 700 bool PluginView::platformGetValue(NPNVariable variable, void* value, NPError* result)
 701 {
 702     switch (variable) {
 703     case NPNVxDisplay:
 704         *(void **)value = QX11Info::display();
 705         *result = NPERR_NO_ERROR;
 706         return true;
 707
 708     case NPNVxtAppContext:
 709         *result = NPERR_GENERIC_ERROR;
 710         return true;
 711
 712     case NPNVnetscapeWindow: {
 713         void* w = reinterpret_cast<void*>(value);
 714         QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
 715         *((XID *)w) = client ? client->ownerWidget()->window()->winId() : 0;
 716         *result = NPERR_NO_ERROR;
 717         return true;
 718     }
 719
 720     case NPNVToolkit:
 721         if (m_plugin->quirks().contains(PluginQuirkRequiresGtkToolKit)) {
 722             *((uint32_t *)value) = 2;
 723             *result = NPERR_NO_ERROR;
 724             return true;
 725         }
 726         return false;
 727
 728     default:
 729         return false;
 730     }
 731 }
 732
 733 void PluginView::invalidateRect(const IntRect& rect)
 734 {
 735 #if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER)
 736     if (m_platformLayer) {
 737         m_platformLayer->update(QRectF(rect));
 738         return;
 739     }
 740 #endif
 741
 742     if (m_isWindowed) {
 743         if (platformWidget()) {
 744             // update() will schedule a repaint of the widget so ensure
 745             // its knowledge of its position on the page is up to date.
 746             QWidget* w = static_cast<QWidget*>(platformWidget());
 747             w->setGeometry(m_windowRect);
 748             w->update(rect);
 749         }
 750         return;
 751     }
 752
 753     invalidateWindowlessPluginRect(rect);
 754 }
 755
 756 void PluginView::invalidateRect(NPRect* rect)
 757 {
 758     if (!rect) {
 759         invalidate();
 760         return;
 761     }
 762     IntRect r(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top);
 763     invalidateRect(r);
 764 }
 765
 766 void PluginView::invalidateRegion(NPRegion region)
 767 {
 768     Q_UNUSED(region);
 769     invalidate();
 770 }
 771
 772 void PluginView::forceRedraw()
 773 {
 774     invalidate();
 775 }
 776
 777 static Display *getPluginDisplay()
 778 {
 779     // The plugin toolkit might run using a different X connection. At the moment, we only
 780     // support gdk based plugins (like flash) that use a different X connection.
 781     // The code below has the same effect as this one:
 782     // Display *gdkDisplay = gdk_x11_display_get_xdisplay(gdk_display_get_default());
 783     QLibrary library(QLatin1String("libgdk-x11-2.0"), 0);
 784     if (!library.load())
 785         return 0;
 786
 787     typedef void *(*gdk_init_check_ptr)(void*, void*);
 788     gdk_init_check_ptr gdk_init_check = (gdk_init_check_ptr)library.resolve("gdk_init_check");
 789     if (!gdk_init_check)
 790         return 0;
 791
 792     typedef void *(*gdk_display_get_default_ptr)();
 793     gdk_display_get_default_ptr gdk_display_get_default = (gdk_display_get_default_ptr)library.resolve("gdk_display_get_default");
 794     if (!gdk_display_get_default)
 795         return 0;
 796
 797     typedef void *(*gdk_x11_display_get_xdisplay_ptr)(void *);
 798     gdk_x11_display_get_xdisplay_ptr gdk_x11_display_get_xdisplay = (gdk_x11_display_get_xdisplay_ptr)library.resolve("gdk_x11_display_get_xdisplay");
 799     if (!gdk_x11_display_get_xdisplay)
 800         return 0;
 801
 802     gdk_init_check(0, 0);
 803     return (Display*)gdk_x11_display_get_xdisplay(gdk_display_get_default());
 804 }
 805
 806 static void getVisualAndColormap(int depth, Visual **visual, Colormap *colormap)
 807 {
 808     *visual = 0;
 809     *colormap = 0;
 810
 811 #ifndef QT_NO_XRENDER
 812     static const bool useXRender = qgetenv("QT_X11_NO_XRENDER").isNull(); // Should also check for XRender >= 0.5
 813 #else
 814     static const bool useXRender = false;
 815 #endif
 816
 817     if (!useXRender && depth == 32)
 818         return;
 819
 820     int nvi;
 821     XVisualInfo templ;
 822     templ.screen  = QX11Info::appScreen();
 823     templ.depth   = depth;
 824     templ.c_class = TrueColor;
 825     XVisualInfo* xvi = XGetVisualInfo(QX11Info::display(), VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi);
 826
 827     if (!xvi)
 828         return;
 829
 830 #ifndef QT_NO_XRENDER
 831     if (depth == 32) {
 832         for (int idx = 0; idx < nvi; ++idx) {
 833             XRenderPictFormat* format = XRenderFindVisualFormat(QX11Info::display(), xvi[idx].visual);
 834             if (format->type == PictTypeDirect && format->direct.alphaMask) {
 835                  *visual = xvi[idx].visual;
 836                  break;
 837             }
 838          }
 839     } else
 840 #endif // QT_NO_XRENDER
 841         *visual = xvi[0].visual;
 842
 843     XFree(xvi);
 844
 845     if (*visual)
 846         *colormap = XCreateColormap(QX11Info::display(), QX11Info::appRootWindow(), *visual, AllocNone);
 847 }
 848
 849 bool PluginView::platformStart()
 850 {
 851     ASSERT(m_isStarted);
 852     ASSERT(m_status == PluginStatusLoadedSuccessfully);
 853
 854     if (m_plugin->pluginFuncs()->getvalue) {
 855         PluginView::setCurrentPluginView(this);
 856 #if USE(JSC)
 857         JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);
 858 #endif
 859         setCallingPlugin(true);
 860         m_plugin->pluginFuncs()->getvalue(m_instance, NPPVpluginNeedsXEmbed, &m_needsXEmbed);
 861         setCallingPlugin(false);
 862         PluginView::setCurrentPluginView(0);
 863     }
 864
 865     if (m_isWindowed) {
 866         QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
 867         if (m_needsXEmbed && client) {
 868             setPlatformWidget(new PluginContainerQt(this, client->ownerWidget()));
 869             // sync our XEmbed container window creation before sending the xid to plugins.
 870             QApplication::syncX();
 871         } else {
 872             notImplemented();
 873             m_status = PluginStatusCanNotLoadPlugin;
 874             return false;
 875         }
 876     } else {
 877         setPlatformWidget(0);
 878         m_pluginDisplay = getPluginDisplay();
 879
 880 #if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER)
 881         if (shouldUseAcceleratedCompositing()) {
 882             m_platformLayer = adoptPtr(new PluginGraphicsLayerQt(this));
 883             // Trigger layer computation in RenderLayerCompositor
 884             m_element->setNeedsStyleRecalc(SyntheticStyleChange);
 885         }
 886 #endif
 887     }
 888
 889     // If the width and the height are not zero we show the PluginView.
 890     if (!frameRect().isEmpty())
 891         show();
 892
 893     NPSetWindowCallbackStruct* wsi = new NPSetWindowCallbackStruct();
 894     wsi->type = 0;
 895
 896     if (m_isWindowed) {
 897         const QX11Info* x11Info = &static_cast<QWidget*>(platformPluginWidget())->x11Info();
 898
 899         wsi->display = x11Info->display();
 900         wsi->visual = (Visual*)x11Info->visual();
 901         wsi->depth = x11Info->depth();
 902         wsi->colormap = x11Info->colormap();
 903
 904         m_npWindow.type = NPWindowTypeWindow;
 905         m_npWindow.window = (void*)static_cast<QWidget*>(platformPluginWidget())->winId();
 906         m_npWindow.width = -1;
 907         m_npWindow.height = -1;
 908     } else {
 909         const QX11Info* x11Info = &QApplication::desktop()->x11Info();
 910
 911         if (x11Info->depth() == 32 || !m_plugin->quirks().contains(PluginQuirkRequiresDefaultScreenDepth)) {
 912             getVisualAndColormap(32, &m_visual, &m_colormap);
 913             wsi->depth = 32;
 914         }
 915
 916         if (!m_visual) {
 917             getVisualAndColormap(x11Info->depth(), &m_visual, &m_colormap);
 918             wsi->depth = x11Info->depth();
 919         }
 920
 921         wsi->display = x11Info->display();
 922         wsi->visual = m_visual;
 923         wsi->colormap = m_colormap;
 924
 925         m_npWindow.type = NPWindowTypeDrawable;
 926         m_npWindow.window = 0; // Not used?
 927         m_npWindow.x = 0;
 928         m_npWindow.y = 0;
 929         m_npWindow.width = -1;
 930         m_npWindow.height = -1;
 931     }
 932
 933     m_npWindow.ws_info = wsi;
 934
 935     if (!(m_plugin->quirks().contains(PluginQuirkDeferFirstSetWindowCall))) {
 936         updatePluginWidget();
 937         setNPWindowIfNeeded();
 938     }
 939
 940     return true;
 941 }
 942
 943 void PluginView::platformDestroy()
 944 {
 945     if (platformPluginWidget())
 946         delete platformPluginWidget();
 947
 948     if (m_drawable)
 949         XFreePixmap(QX11Info::display(), m_drawable);
 950
 951     if (m_colormap)
 952         XFreeColormap(QX11Info::display(), m_colormap);
 953 }
 954
 955 #if USE(ACCELERATED_COMPOSITING)
 956 PlatformLayer* PluginView::platformLayer() const
 957 {
 958     return m_platformLayer.get();
 959 }
 960 #endif
 961
 962 } // namespace WebCore