diff options
Diffstat (limited to 'src/3rdparty/webkit/WebCore')
68 files changed, 2156 insertions, 528 deletions
diff --git a/src/3rdparty/webkit/WebCore/ChangeLog b/src/3rdparty/webkit/WebCore/ChangeLog index 6617b6617b..c17a8aa8a1 100644 --- a/src/3rdparty/webkit/WebCore/ChangeLog +++ b/src/3rdparty/webkit/WebCore/ChangeLog @@ -1,3 +1,1177 @@ +2010-06-17 Mark Brand <mabrand@mabrand.nl> + + Reviewed by Simon Hausmann. + + [Qt] use "win32-g++*" scope to match all MinGW makespecs + + The scope "win32-g++" comes from the name of the makespec. However, it + is frequently used to check for MinGW. This works fine as long as + win32-g++ is the only makespec for MinGW. Now we need the wildcard + to cover "win32-g++-cross" as well. + + * WebCore.pro: + +2010-06-16 Antonio Gomes <tonikitoo@webkit.org> + + Reviewed by Kenneth Christiansen. + + Spatial Navigation: using offset{Left,Top} is not enough to get the proper inner frames position + https://bugs.webkit.org/show_bug.cgi?id=39439 + + As pointed out by Darin Adler in https://bugs.webkit.org/show_bug.cgi?id=18662#c20, + "It's not correct to use the offsetLeft and offsetTop of the frame owner element's renderer because + that's just the distance from the offsetParent, not the absolute position". + + Patch fixes that behavior by now considering the offsetTop and offsetLeft the offsetParent recursively, + starting from the HtmlFrameOwnerElement. Previously, only calling offsetTop and offsetLeft works + because all tests were done in htmls where the {i}frame element was a directly a child of the body, + e.g. <html>...<body><iframe src=xxx>....<body></html>. + + Test: fast/events/spatial-navigation/snav-iframe-recursive-offset-parent.html + + * page/SpatialNavigation.cpp: + (WebCore::renderRectRelativeToRootDocument): + +2010-06-16 Antonio Gomes <tonikitoo@webkit.org> + + Reviewed by Simon Fraser. + + Spatial Navigation: refactor scrollInDirection to work with scrollable content + https://bugs.webkit.org/show_bug.cgi?id=39195 + + scrollInDirection now receives as parameter the node that the Spatial Navigation + found as the more appropriated to move focus to. If it is in a scrollable container + (e.g. <div> with clipped overflow content), it scrolls recursively starting from + the container, not the current focused node. + + Test: fast/events/spatial-navigation/snav-only-clipped-overflow-content.html + + * page/FocusController.cpp: + (WebCore::FocusController::advanceFocusDirectionally): + * page/SpatialNavigation.cpp: + (WebCore::scrollInDirection): + * page/SpatialNavigation.h: + +2010-05-28 Viatcheslav Ostapenko <ostapenko.viatcheslav@nokia.com> + + Reviewed by Simon Hausmann, Antti Koivisto + + Make repaint throttling parameters runtime configurable. + https://bugs.webkit.org/show_bug.cgi?id=38401 + + REPAINT_THROTTLING now chooses default values for throttling parameters. + Should be removed when applications start using runtime configuration. + + * page/FrameView.cpp: + (WebCore::FrameView::reset): + (WebCore::FrameView::updateDeferredRepaintDelay): + (WebCore::FrameView::setRepaintThrottlingDeferredRepaintDelay): + (WebCore::FrameView::setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading): + (WebCore::FrameView::setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading): + (WebCore::FrameView::setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading): + * page/FrameView.h: + +2010-06-16 Dawit Alemayehu <adawit@kde.org> + + Reviewed by Simon Hausmann. + + [Qt] QtWebKit crashes while initializing flash plugin 10.1.53.64. + https://bugs.webkit.org/show_bug.cgi?id=40567 + + Avoid preventable crashes by ensuring gtk_init() is called in the + flash viewer plugins before calling NP_Initialize. + + * plugins/qt/PluginPackageQt.cpp: + (WebCore::PluginPackage::load): + +2010-04-21 Zoltan Herczeg <zherczeg@webkit.org> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] startAnimation() is not needed to preceede nativeImageForCurrentFrame() + https://bugs.webkit.org/show_bug.cgi?id=37844 + + nativeImageForCurrentFrame() resets the m_decoder parameter under Qt, + which is required by startAnimation() to detect frame and repetition counts. + Hence, Image::drawTiled cannot start animations under Qt: + <html><body background="animated.gif"></body></html> does not work + + * platform/graphics/qt/ImageDecoderQt.cpp: + (WebCore::ImageDecoderQt::internalHandleCurrentImage): + +2010-05-28 Peter Kasting <pkasting@google.com> + + Reviewed by Darin Adler. + + https://bugs.webkit.org/show_bug.cgi?id=39857 + Make GIFs loop the correct number of times. Previously, everyone looped + one time too few for non-infinitely-looping GIFs. + + Modified a Qt manual test to be correct and moved it to the general + manual test directory. + + * manual-tests/animated-gif-looping.html: Copied from WebCore/manual-tests/qt/qt-gif-test.html. + * manual-tests/qt/qt-10loop-anim.gif: Removed. + * manual-tests/qt/qt-anim.gif: Removed. + * manual-tests/qt/qt-gif-test.html: Removed. + * manual-tests/qt/qt-noanim.gif: Removed. + * manual-tests/resources/animated-10x.gif: Copied from WebCore/manual-tests/qt/qt-10loop-anim.gif and modified. + * manual-tests/resources/animated-infinite.gif: Copied from WebCore/manual-tests/qt/qt-anim.gif. + * manual-tests/resources/non-animated.gif: Copied from WebCore/manual-tests/qt/qt-noanim.gif. + * platform/graphics/BitmapImage.cpp: + (WebCore::BitmapImage::internalAdvanceAnimation): For a loop count of n, show a total of n + 1 animation cycles. + * platform/graphics/ImageSource.h: + * platform/graphics/cg/ImageSourceCG.cpp: + (WebCore::ImageSource::repetitionCount): + * platform/graphics/qt/ImageDecoderQt.cpp: + (WebCore::ImageDecoderQt::repetitionCount): Remove translation code now that WebCore matches Qt's internal handling of the loop count. Qt itself may still have a bug here. + * platform/image-decoders/gif/GIFImageDecoder.cpp: + (WebCore::GIFImageDecoder::repetitionCount): + * platform/image-decoders/gif/GIFImageReader.cpp: + (GIFImageReader::read): Translate loop count 0 to "loop infinitely" (by restoring one piece of the Mozilla code we'd removed). + +2010-05-04 Tucker Jay <jay.tucker@nokia.com> + + Reviewed by Holger Freyther. + + Animated GIF images does not animate 10x as expected by default. + https://bugs.webkit.org/show_bug.cgi?id=36818 + + Added test case to existing manual test to test the + fixed functionality. + + * manual-tests/qt/qt-10loop-anim.gif: Added. + * manual-tests/qt/qt-gif-test.html: + * platform/graphics/qt/ImageDecoderQt.cpp: + (WebCore::ImageDecoderQt::repetitionCount): + +2010-05-16 Antonio Gomes <tonikitoo@webkit.org> + + Unreviewed naming fixes of local variables used in Spatial Navigation methods. + + Summary: + * "candidate" renamed to "node"; + * "currentFocusCandidate" renamed to "candidate" + * "closestFocusCandidate" renamed to "closest" + + That way naming is more consistent in the various Spatial Navigation methods. + + * page/FocusController.cpp: + (WebCore::FocusController::findFocusableNodeInDirection): + (WebCore::FocusController::deepFindFocusableNodeInDirection): + +2010-06-14 Antonio Gomes <tonikitoo@webkit.org> + + Reviewed by Simon Fraser and Kenneth Christiansen. + + Spatial Navigation: make it work with focusable elements in overflow content + https://bugs.webkit.org/show_bug.cgi?id=36463 + + This patch addresses the problem with Spatial Navigation. It currently does not + properly traverse scrollable contents, including scrollable div's. For this to work, + a new class member called scrollableEnclosingBox was introduced to FocusCandidate class which + keeps track of the current scrollable box Node wrapping a FocusCandidate. + + To make use of enclosingScrollableBox of FocusCandidate, the DOM traversal routine + (FocusController::findNextFocusableInDirection) was changed as follows: when it + encounters a scrollable Node, each focusable node which is 'inner' keeps track of + the container reference. By the time a sibling of the scrollable Node is encountered, + there is no need to track this reference any more and the traversal algorithm continues + normally. + + The common case is obviously that there is no scrollable container wrapping it. + + updateFocusCandiditeIfCloser logic was also adapted to fit the need of the + newly introduced enclosingScrollableBox class member, getting simpler and more + easily maintainable. + + Tests: fast/events/spatial-navigation/snav-div-scrollable-but-without-focusable-content.html + fast/events/spatial-navigation/snav-clipped-overflow-content.html + + * page/FocusController.cpp: + (WebCore::updateFocusCandidateInSameContainer): + (WebCore::updateFocusCandidateIfCloser): + (WebCore::FocusController::findFocusableNodeInDirection): + (WebCore::FocusController::deepFindFocusableNodeInDirection): + * page/SpatialNavigation.cpp: + (WebCore::isScrollableContainerNode): + * page/SpatialNavigation.h: + (WebCore::FocusCandidate::FocusCandidate): + (WebCore::FocusCandidate::isInScrollableContainer): + +2010-06-15 Jocelyn Turcotte <jocelyn.turcotte@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] The qt_webkit_version.pri file gets overwritten on install + https://bugs.webkit.org/show_bug.cgi?id=40487 + + Don't install qt_webkit_version.pri when building WebKit inside of Qt. + The import of WebKit into Qt will take care of providing the file + in mkspecs/modules and it'll be installed through projects.pro. + + * WebCore.pro: + +2010-06-13 Noam Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Eric Seidel. + + [Qt] GraphicsLayer: recaching images creates an unnecessary deep copy + https://bugs.webkit.org/show_bug.cgi?id=40535 + + Made sure the painter ends its operation before copying the pixmap. + + No new tests: this is an optimization. + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::GraphicsLayerQtImpl::recache): + +2010-03-24 Dumitru Daniliuc <dumi@chromium.org> + + Reviewed by Dimitri Glazkov. + + Changing the V8 and JSC implementations of + SQLStatementErrorCallback to interpret as false all results that + could be converted to a false boolean. Pretty much a revert of + r54981. + + https://bugs.webkit.org/show_bug.cgi?id=36569 + + * bindings/js/JSCustomSQLStatementErrorCallback.cpp: + (WebCore::JSCustomSQLStatementErrorCallback::handleEvent): + * bindings/v8/custom/V8CustomSQLStatementErrorCallback.cpp: + (WebCore::V8CustomSQLStatementErrorCallback::handleEvent): + * bindings/v8/custom/V8CustomVoidCallback.cpp: + (WebCore::invokeCallback): + * bindings/v8/custom/V8CustomVoidCallback.h: + +2010-06-13 Noam Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] tests/hybridPixmap fails + https://bugs.webkit.org/show_bug.cgi?id=37316 + + The problem was that JSC::Instance::createRuntimeObject was never called. + This is fixed by overloading newRuntimeObject and calling Instance::createRuntimeObject + in between, instead of creating the runtime object directly inside the static function + QtPixmapInstance::createRuntimeObject, which had to be renamed as to not overshadow the virtual function. + + This fixes an existing test, tests/hybridPixmap + + * bridge/qt/qt_pixmapruntime.cpp: + (JSC::Bindings::QtPixmapInstance::newRuntimeObject): + (JSC::Bindings::QtPixmapInstance::createPixmapRuntimeObject): + * bridge/qt/qt_pixmapruntime.h: + * bridge/qt/qt_runtime.cpp: + (JSC::Bindings::convertQVariantToValue): + +2010-06-07 Mahesh Kulakrni <mahesh.kulkarni@nokia.com> + + Reviewed by Simon Hausmann. + + [QT] QT_BEARER flag is not enabled on S60 properly + https://bugs.webkit.org/show_bug.cgi?id=39357 + + enable QT_BEARER for all platform based on qtmobility + + bearer module availability or for qt 4.7+ + + * WebCore.pri: + +2010-06-09 Csaba Osztrogonác <ossy@webkit.org> + + Reviewed by Dirk Schulze. + + [Qt] Imperfect dependency for generated SVGNames.cpp + https://bugs.webkit.org/show_bug.cgi?id=40359 + + * WebCore.pri: Missing dependency added. + +2010-06-08 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org> + + Unreviewed Buildbot fix. + + Reset the Qt TextBreakIterator when reusing it. + + * platform/text/qt/TextBreakIteratorQt.cpp: + (WebCore::setUpIterator): + +2010-06-08 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org> + + Reviewed by Antti Koivisto. + + [Qt] TextBreakIterator Qt performance + https://bugs.webkit.org/show_bug.cgi?id=39958 + + Rework TextBreakIteratorQt to be more in line with the ICU version. + + We now reuse iterators where ever possible. The string data is compared + with memcmp, which should be faster than using a hash, as you need + to traverse the full buffer in the case the strings don't match, + where as the compare would fail quickly. + + * platform/text/qt/TextBreakIteratorQt.cpp: + (WebCore::TextBreakIterator::TextBreakIterator): + (WebCore::setUpIterator): + (WebCore::wordBreakIterator): + (WebCore::characterBreakIterator): + (WebCore::lineBreakIterator): + (WebCore::sentenceBreakIterator): + +2010-06-07 Jocelyn Turcotte <jocelyn.turcotte@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix text selection drawing. + https://bugs.webkit.org/show_bug.cgi?id=40221 + + The regression was introduced in r60169. + + * platform/graphics/qt/FontQt.cpp: + (WebCore::drawTextCommon): + +2010-06-04 No'am Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] Fix compilation with QT_NO_FEATURE + https://bugs.webkit.org/show_bug.cgi?id=38324 + + The #ifdef QT_NO_GRAPHICSEFFECT was in the wrong place, would have + made AC not work at all. + + No new tests. + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::GraphicsLayerQtImpl::flushChanges): + +2010-05-24 Tasuku Suzuki <tasuku.suzuki@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] Fix compilation with QT_NO_TEMPORARYFILE + https://bugs.webkit.org/show_bug.cgi?id=38324 + + * platform/qt/FileSystemQt.cpp: + (WebCore::openTemporaryFile): + +2010-05-21 Tasuku Suzuki <tasuku.suzuki@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix compilation with QT_NO_GRAPHICSEFFECT + https://bugs.webkit.org/show_bug.cgi?id=38324 + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::GraphicsLayerQtImpl::flushChanges): + +2010-05-02 Tasuku Suzuki <tasuku.suzuki@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix compilation with QT_NO_BEARERMANAGEMENT + https://bugs.webkit.org/show_bug.cgi?id=38324 + + * platform/network/NetworkStateNotifier.h: + * platform/network/qt/NetworkStateNotifierQt.cpp: + +2010-05-02 Tasuku Suzuki <tasuku.suzuki@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix compilation with QT_NO_LINEEDIT + https://bugs.webkit.org/show_bug.cgi?id=38324 + + * platform/qt/RenderThemeQt.cpp: + (WebCore::RenderThemeQt::~RenderThemeQt): + (WebCore::RenderThemeQt::findFrameLineWidth): + +2010-06-04 Simon Hausmann <simon.hausmann@nokia.com> + + Reviewed by Tor Arne Vestbø. + + [Qt] Compilation fails when compiling against Qt 4.7 and Qt Mobility is installed + https://bugs.webkit.org/show_bug.cgi?id=40116 + + CONFIG += mobility has the side-effect of pulling in mobility includes, which conflict + with Qt 4.7's bearer managenent includes and break the build. + + * WebCore.pro: + +2010-06-03 Tor Arne Vestbø <tor.arne.vestbo@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix NPAPI support on Mac OS X/Cocoa-32 + + qt_mac_window_for() returns a NSWindow on Cocoa, so we were + passing in a NSWindow instead of a WindowRef as part of the + NP_CGContext. + + https://bugs.webkit.org/show_bug.cgi?id=38762 + + * WebCore.gypi: Reflect rename + * WebCore.pro: Reflect rename + * plugins/mac/PluginViewMac.cpp: Renamed to PluginViewMac.mm + and fix bug by getting the Carbon windowRef from the NSWindow. + * wscript: Reflect rename + +2010-06-02 Nico Weber <thakis@chromium.org> + + Reviewed by Simon Fraser. + + Scroll events are sent twice per keypress for ports that don't have a platformWidget scrollbar + https://bugs.webkit.org/show_bug.cgi?id=39918 + + This was regressed by http://trac.webkit.org/changeset/58615 . Fix this by slightly tweaking + that patch. + + Test: editing/input/page-up-down-scrolls.html + + * page/FrameView.cpp: + (WebCore::FrameView::scrollPositionChanged): + * page/FrameView.h: + * platform/ScrollView.cpp: + (WebCore::ScrollView::valueChanged): + * platform/ScrollView.h: + (WebCore::ScrollView::repaintFixedElementsAfterScrolling): + +2010-06-02 Jocelyn Turcotte <jocelyn.turcotte@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix make install on Symbian for headers in package builds when INSTALL_HEADERS is not defined + + First we wrote inst_headers.output with $$[QT_INSTALL_HEADERS] and then + overwrote it with the $$INSTALL_HEADERS variant without checking if the + variable was set. + + Fixed and cleaned up the logic of falling back to $$[QT_INSTALL_HEADERS]. + + * WebCore.pro: + +2010-06-01 No'am Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] GraphicsLayer: warnings when reloading page + https://bugs.webkit.org/show_bug.cgi?id=39694 + + Made sure recaching and masks aren't attempted on zero-size layers. + + No new tests. Old tests (e.g. LayoutTests/compositing/masks) show the problem. + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::MaskEffectQt::draw): + (WebCore::GraphicsLayerQtImpl::recache): + +2010-05-10 Rodrigo Belem <rodrigo.belem@openbossa.org> + + Reviewed by Kenneth Christiansen , Simon Hausmann and Gustavo Noronha. + + [Qt, Gtk] Allows build-webkit script to receive an install prefix as parameter + https://bugs.webkit.org/show_bug.cgi?id=26224 + + This patch adds the ability, in the QtWebkit build system, to change + the installation path. + + * WebCore.pro: + +2010-06-01 Simon Hausmann <simon.hausmann@nokia.com> + + Reviewed by Laszlo Gombos. + + [Qt] Fix installation of the QtWebKit module .pri file when building inside of Qt + + * WebCore.pro: + +2010-06-01 Jocelyn Turcotte <jocelyn.turcotte@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix a QtWebKit.pc corruption problem. + https://bugs.webkit.org/show_bug.cgi?id=36826 + + The problem occurs while installing QtWebKit from trunk + or a source package. + + * WebCore.pro: + +2010-06-01 Simon Hausmann <simon.hausmann@nokia.com> + + Reviewed by Laszlo Gombos. + + [Qt] Fix Symbian package dependencies of apps against QtWebKit when installing into Qt + + Install the versioning qt_webkit_version.pri into $$[QMAKE_MKSPECS]/modules, which is + where mkspecs/features/qt.prf expects it. + + * WebCore.pro: + +2010-05-17 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + Bring CanvasRenderingContext2D's createImageData() in line with HTML5 spec + Added createImageData(ImageData) which returns a new ImageData with the same size as the one passed. + Changed createImageData(width, height) to use the absolute values of width and height. + + https://bugs.webkit.org/show_bug.cgi?id=39189 + + Spec link: + http://www.whatwg.org/specs/web-apps/current-work/#dom-context-2d-createimagedata + + Test: fast/canvas/canvas-createImageData.html + + * bindings/js/JSCanvasRenderingContext2DCustom.cpp: + (WebCore::JSCanvasRenderingContext2D::createImageData): + * html/canvas/CanvasRenderingContext2D.cpp: + (WebCore::CanvasRenderingContext2D::createImageData): + * html/canvas/CanvasRenderingContext2D.h: + * html/canvas/CanvasRenderingContext2D.idl: + +2010-05-16 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + Properly handle invalid arguments to CanvasRenderingContext2D's getImageData() and putImageData(). + Both should throw NOT_SUPPORTED_ERR when called with nonfinite arguments. + getImageData() should throw INDEX_SIZE_ERR if either width or height is 0. + + https://bugs.webkit.org/show_bug.cgi?id=39175 + + Spec link: + http://www.whatwg.org/specs/web-apps/current-work/#pixel-manipulation + + Test: fast/canvas/canvas-getImageData-invalid.html + + * html/canvas/CanvasRenderingContext2D.cpp: + (WebCore::CanvasRenderingContext2D::createImageData): + (WebCore::CanvasRenderingContext2D::getImageData): + (WebCore::CanvasRenderingContext2D::putImageData): + +2010-05-31 Oswald Buddenhagen <oswald.buddenhagen@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Escape backslashes in the .pro files + + qmake in Qt 4.7 warns about unescaped backspaces and deprecates them. + + * WebCore.pro: + +2010-05-28 Antti Koivisto <koivisto@iki.fi> + + Reviewed by Kenneth Rohde Christiansen. + + https://bugs.webkit.org/show_bug.cgi?id=39874 + [Qt] Make tiled backing store more configurable + + Make tile size, tile creation delay and tiling area dynamically configurable. + + * platform/graphics/TiledBackingStore.cpp: + (WebCore::TiledBackingStore::TiledBackingStore): + (WebCore::TiledBackingStore::setTileSize): + (WebCore::TiledBackingStore::setTileCreationDelay): + (WebCore::TiledBackingStore::setKeepAndCoverAreaMultipliers): + (WebCore::TiledBackingStore::createTiles): + * platform/graphics/TiledBackingStore.h: + (WebCore::TiledBackingStore::tileSize): + (WebCore::TiledBackingStore::tileCreationDelay): + (WebCore::TiledBackingStore::getKeepAndCoverAreaMultipliers): + +2010-05-28 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] REGRESSION(r59837): Incorrect clipping of TransparencyLayers + https://bugs.webkit.org/show_bug.cgi?id=39784 + + Move coordinate transformation from TransparencyLayer to clipToImageBuffer() + + * platform/graphics/qt/GraphicsContextQt.cpp: + (WebCore::TransparencyLayer::TransparencyLayer): + (WebCore::GraphicsContext::clipToImageBuffer): + +2010-05-13 Antti Koivisto <koivisto@iki.fi> + + Reviewed by Kenneth Rohde Christiansen. + + https://bugs.webkit.org/show_bug.cgi?id=39063 + [Qt] Tiled backing store checker pattern does not paint correctly when scaling factor is not 1 + + Use the dirty rect that has been adjusted for scaling instead of the original one. + + * platform/graphics/TiledBackingStore.cpp: + (WebCore::TiledBackingStore::paint): + +2010-05-24 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Reviewed by Simon Hausmann. + + [Qt] Make text filling work together with text stroke. + + When the text has stroke a new QPen was set, overriding the pen + set for text filling. This patch fixes that by storing the two + pens and using where appropriate. + + * platform/graphics/qt/FontQt.cpp: + (WebCore::Font::drawComplexText): + +2010-05-17 Antonio Gomes <tonikitoo@webkit.org> + + Reviewed by Darin Adler. + + Add an optional "starting node' parameter to scrollRecursively and scrollOverflow of EventHandler + https://bugs.webkit.org/show_bug.cgi?id=39217 + + It would be usefull if scrollOverflow and scrollRecursively methods of EventHandler + could receive a parameter to specify where to start scrolling from. Currently they + start scrolling from either the current focused node or the node where mouse last + pressed on. Patch proposes an aditional starting point as an optional parameter. + Since it is optional, all call sites can remain as are, and if a Null node is passed + in, both methods work as previously. + + * page/EventHandler.cpp: + (WebCore::EventHandler::scrollOverflow): + (WebCore::EventHandler::scrollRecursively): + * page/EventHandler.h: + +2010-05-23 Noam Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] Using Accelerated Composing the rocket back animation on http://www.the-art-of-web.com/css/css-animation/ works differently as when not using AC. + https://bugs.webkit.org/show_bug.cgi?id=39513 + + The value of GraphicsLayer->transform() needs to be changed during the animation, regardless of m_fillsForward. + m_fillsForward should only apply at the end of the animation. Based on previous patch by Kenneth Christiansen. + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::TransformAnimationQt::applyFrame): + (WebCore::OpacityAnimationQt::applyFrame): + +2010-05-25 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org> + + Reviewed by Laszlo Gombos. + + [Qt] Running with accelerated compositing enabled sometimes result in a crash + https://bugs.webkit.org/show_bug.cgi?id=39609 + + Check if we have a scene before applying the workaround for + the QGraphicsScene bug where opacity change doesn't always have + immediate effect. + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::OpacityAnimationQt::applyFrame): + +2010-05-19 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Reviewed by Simon Hausmann. + + Fix painting when using clipToImageBuffer() + + When we apply the transform of the parent painter to the painter of + the transparency layer, we adopt its coordinate system, thus offset + should not be in page coordinates, but in the coordinate system of + the parent painter. + + * platform/graphics/qt/GraphicsContextQt.cpp: + (WebCore::TransparencyLayer::TransparencyLayer): + +2010-05-19 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] REGRESSION: CoolClock isn't rendered properly + + https://bugs.webkit.org/show_bug.cgi?id=38526 + + CanvasRenderingContext2D's arc() should connect to the previous point + with a straight line (HTML5 spec 4.8.11.1.8), but if the path is empty + to begin with, we don't want a line back to (0,0) + This also fixes the rendering artifact discussed in bug 36226. + + Spec link: + http://www.whatwg.org/specs/web-apps/current-work/#dom-context-2d-arc + + Test: fast/canvas/canvas-arc-connecting-line.html + + * platform/graphics/qt/PathQt.cpp: + (WebCore::Path::addArc): + +2010-05-18 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Rubberstamped by Simon Hausmann. + + Return null when creating an ImageBuffer failed, due to for + instance a nulled pixmap. + + * platform/graphics/qt/ImageBufferQt.cpp: + (WebCore::ImageBufferData::ImageBufferData): + (WebCore::ImageBuffer::ImageBuffer): + +2010-05-17 Antti Koivisto <koivisto@iki.fi> + + Reviewed by Kenneth Rohde Christiansen. + + https://bugs.webkit.org/show_bug.cgi?id=39218 + [Qt] Tiled backing store tiles sometimes flicker when exiting a zoom animation + + Tiles sometimes flicker when exiting a zoom animation. This happens as a result + of the visible rectangle being momentarily out of sync. + + Instead of updating the visible rect by explicitly setting it, pull it through + the client and recompute in the WebKit level. + + * page/ChromeClient.h: + (WebCore::ChromeClient::visibleRectForTiledBackingStore): + * page/Frame.cpp: + (WebCore::Frame::tiledBackingStoreVisibleRect): + * page/Frame.h: + * platform/graphics/TiledBackingStore.cpp: + (WebCore::TiledBackingStore::checkVisibleRectChanged): + (WebCore::TiledBackingStore::createTiles): + * platform/graphics/TiledBackingStore.h: + * platform/graphics/TiledBackingStoreClient.h: + +2010-05-18 Zoltan Herczeg <zherczeg@webkit.org> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] Implementing clipToImageBuffer for Qt port. + https://bugs.webkit.org/show_bug.cgi?id=24289 + + The implementation combines pixmap layers and destinationIn + composition mode. + + * platform/graphics/qt/GraphicsContextQt.cpp: + (WebCore::TransparencyLayer::TransparencyLayer): + (WebCore::GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate): + (WebCore::GraphicsContext::savePlatformState): + (WebCore::GraphicsContext::restorePlatformState): + (WebCore::GraphicsContext::inTransparencyLayer): + (WebCore::GraphicsContext::beginTransparencyLayer): + (WebCore::GraphicsContext::endTransparencyLayer): + (WebCore::GraphicsContext::clipToImageBuffer): + +2010-05-16 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + Canvas's toDataURL() should be case insensitive wrt the mimeType argument. + https://bugs.webkit.org/show_bug.cgi?id=39153 + + Spec link: + http://www.whatwg.org/specs/web-apps/current-work/#dom-canvas-todataurl + + Test: fast/canvas/canvas-toDataURL-case-insensitive-mimetype.html + + * dom/CanvasSurface.cpp: + (WebCore::CanvasSurface::toDataURL): + +2010-05-16 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + Canvas's getContext() must return null when called with an invalid/unsupported parameter. + (HTML5 spec 4.8.11): http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-canvas-getcontext + + https://bugs.webkit.org/show_bug.cgi?id=39150 + + Test: fast/canvas/canvas-getContext-invalid.html + + * bindings/js/JSHTMLCanvasElementCustom.cpp: + (WebCore::JSHTMLCanvasElement::getContext): + * bindings/v8/custom/V8HTMLCanvasElementCustom.cpp: + (WebCore::V8HTMLCanvasElement::getContextCallback): + +2010-05-17 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Reviewed by Laszlo Gombos. + + REGRESSION(59563): [Qt] JSValue QtClass::fallbackObject can be optimized + + Patch declared a variable index, which shadowed an earlier declared + variable. + + * bridge/qt/qt_class.cpp: + (JSC::Bindings::QtClass::fallbackObject): + +2010-05-14 Noam Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] GraphicsLayer caches directly composited images + https://bugs.webkit.org/show_bug.cgi?id=38444 + + Directly-composited images and solid fills shouldn't be cached, as that cache + is never used (see GraphicsLayerQtImpl::paint). Cache is only relevant for HTML content, + but we were missing that test. + The fix makes sure we only cache HTML content. + + No new tests: this is a minor optimization. + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::GraphicsLayerQtImpl::flushChanges): + +2010-05-15 Anders Bakken <agbakken@gmail.com> + + Reviewed by Kenneth Rohde Christiansen. + + Don't unnecessarily copy data when searching for methods in QtClass. + + [Qt] JSValue QtClass::fallbackObject can be optimized + https://bugs.webkit.org/show_bug.cgi?id=37684 + + * bridge/qt/qt_class.cpp: + (JSC::Bindings::QtClass::fallbackObject): + +2010-05-06 Luiz Agostini <luiz.agostini@openbossa.org> + + Rubber-stamped by Simon Hausmann. + + [Qt] use QT_MOBILE_THEME in Symbian + https://bugs.webkit.org/show_bug.cgi?id=38440 + + Putting QT_MOBILE_THEME into use for Symbian. + + * WebCore.pro: + +2010-05-14 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Darin Adler. + + CSSParser::parseColor() shouldn't alter 'color' unless passed a valid color string. + https://bugs.webkit.org/show_bug.cgi?id=39031 + + * css/CSSParser.cpp: + (WebCore::CSSParser::parseColor): + * editing/ApplyStyleCommand.cpp: + (WebCore::StyleChange::extractTextStyles): Don't depend on old behavior. + * html/canvas/CanvasRenderingContext2D.cpp: + (WebCore::CanvasRenderingContext2D::setShadow): Remove dead code. + +2010-05-14 Aaron Kennedy <tffeeb@gmail.com> + + Reviewed by Simon Hausmann. + + [Qt] JavaScript unable to invoke methods declared in QML + https://bugs.webkit.org/show_bug.cgi?id=38949 + + JavaScript code executed by webkit cannot call into QML declared + methods, as it does not check for dynamic meta objects. + + * bridge/qt/qt_instance.cpp: + (JSC::Bindings::QtInstance::stringValue): Use QMetaObject::metacall. + * bridge/qt/qt_runtime.cpp: + (JSC::Bindings::QtRuntimeMetaMethod::call): Ditto. + +2010-05-12 Laszlo Gombos <laszlo.1.gombos@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] Detect debug mode consistently + https://bugs.webkit.org/show_bug.cgi?id=38863 + + No new tests as there is no new functionality. + + * WebCore.pro: + +2010-05-14 Andreas Kling <andreas.kling@nokia.com> + + Reviewed by Darin Adler. + + Ignore invalid values for various CanvasRenderingContext2D properties + (lineWidth, miterLimit, shadowOffsetX, shadowOffsetY and shadowBlur) + + https://bugs.webkit.org/show_bug.cgi?id=38841 + + Test: fast/canvas/canvas-invalid-values.html + + * html/canvas/CanvasRenderingContext2D.cpp: + (WebCore::CanvasRenderingContext2D::setLineWidth): + (WebCore::CanvasRenderingContext2D::setMiterLimit): + (WebCore::CanvasRenderingContext2D::setShadowOffsetX): + (WebCore::CanvasRenderingContext2D::setShadowOffsetY): + (WebCore::CanvasRenderingContext2D::setShadowBlur): + +2010-05-12 Noam Rosenthal <noam.rosenthal@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] GraphicsLayer: depth-test causes flicker in certain situations + + This patch removes the simplistic 2D depth test as it leads to flickering side effects. + https://bugs.webkit.org/show_bug.cgi?id=38370 + + Tested by http://webkit.org/blog-files/3d-transforms/morphing-cubes.html + + * platform/graphics/qt/GraphicsLayerQt.cpp: + (WebCore::GraphicsLayerQtImpl::updateTransform): + +2010-04-29 James Robinson <jamesr@chromium.org> + + Reviewed by Simon Fraser. + + Calls FrameView::scrollPositionChanged whenever a ScrollView is scrolled + https://bugs.webkit.org/show_bug.cgi?id=38286 + + When a ScrollView's scroll position is changed, we have to call + FrameView::scrollPositionChanged to generate repaint invalidation for + fixed position elements. This ends up getting called indirectly when + the ScrollView has a platformWidget through the port layer + (see WebHTMLView.mm's _frameOrBoundsChanged method for how the mac + port does it) but not when there is no platformWidget. + + This is tested by the fast/repaint/fixed-* tests when run in pixel + mode. + + Test: fast/repaint/fixed-move-after-keyboard-scroll.html + + * page/FrameView.h: + * platform/ScrollView.cpp: + (WebCore::ScrollView::valueChanged): + * platform/ScrollView.h: + (WebCore::ScrollView::scrollPositionChanged): + +2010-04-23 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Unreviewed build fix. + + Change Media to StyleMedia + + * DerivedSources.make: + +2010-04-22 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Reviewed by Laszlo Gombos. + + Rename window.media to window.styleMedia + https://bugs.webkit.org/show_bug.cgi?id=36187 + + Rename the interface Media to StyleMedia as required by the + new CSSOM View spec. + + * Android.derived.jscbindings.mk: + * Android.derived.v8bindings.mk: + * GNUmakefile.am: + * WebCore.gypi: + * WebCore.pri: + * WebCore.pro: + * WebCore.vcproj/WebCore.vcproj: + * WebCore.xcodeproj/project.pbxproj: + * css/Media.cpp: Removed. + * css/Media.h: Removed. + * css/Media.idl: Removed. + * css/StyleMedia.cpp: Added. + (WebCore::StyleMedia::StyleMedia): + (WebCore::StyleMedia::type): + (WebCore::StyleMedia::matchMedium): + * css/StyleMedia.h: Added. + (WebCore::StyleMedia::create): + (WebCore::StyleMedia::disconnectFrame): + * css/StyleMedia.idl: Added. + * page/DOMWindow.cpp: + (WebCore::DOMWindow::styleMedia): + * page/DOMWindow.h: + (WebCore::DOMWindow::optionalMedia): + * page/DOMWindow.idl: + +2010-04-22 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Reviewed by Simon Fraser. + + Rename window.media to window.styleMedia + https://bugs.webkit.org/show_bug.cgi?id=36187 + + It has been defined that the AbstractView media extension + defined in the CSSOM View spec should be renamed to styleMedia. + This patch does that and updates the current layout tests + making use of it. + + * page/AbstractView.idl: + * page/DOMWindow.cpp: + (WebCore::DOMWindow::styleMedia): + * page/DOMWindow.h: + * page/DOMWindow.idl: + +2010-05-11 Benjamin Poulain <benjamin.poulain@nokia.com> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] fast/text/find-hidden-text.html + https://bugs.webkit.org/show_bug.cgi?id=32922 + + Use the real page step for populating the QStyleOption otherwhise + the size can be negative, which can break the QStyle used. + + * platform/qt/ScrollbarThemeQt.cpp: + (WebCore::styleOptionSlider): + +2010-05-03 Antonio Gomes <tonikitoo@webkit.org> + + Reviewed by Kenneth Christiansen. + + Spatial Navigation: create a getter for the "fudgeFactor" + https://bugs.webkit.org/show_bug.cgi?id=38488 + + A couple of places in the Spatial Navigation code make use of a "fudge factor" + to improve precision by working around outline focus metrics and such. Patch adds + a helper method for unify getter operations of this value, instead of having it + declared locally in the various methods it is used. + + No behaviour change. + + * page/SpatialNavigation.cpp: + (WebCore::scrollIntoView): + (WebCore::deflateIfOverlapped): + * page/SpatialNavigation.h: + (WebCore::fudgeFactor): + +2010-05-10 Markus Goetz <Markus.Goetz@nokia.com> + + Reviewed by Simon Hausmann. + + Qt after 4.6.3 has its integrated DNS cache. Therefore some + code is not necessary anymore. + + https://bugs.webkit.org/show_bug.cgi?id=38834 + + * platform/network/qt/DnsPrefetchHelper.h: + (WebCore::DnsPrefetchHelper::lookup): + (WebCore::DnsPrefetchHelper::lookedUp): + +2010-05-06 Laszlo Gombos <laszlo.1.gombos@nokia.com> + + Unreviewed, build fix WinCE for QtWebKit. + + [Qt] Compilation with Plugins disabled is broken + https://bugs.webkit.org/show_bug.cgi?id=31407 + + Rename platform/qt/TemporaryLinkStubs.cpp to avoid name collition on + Windows. + + Thanks for Ismail "cartman" Donmez for help. + + No new tests, as there is no new functionality. + + * WebCore.gypi: + * WebCore.pro: + * platform/qt/TemporaryLinkStubs.cpp: Removed. + * platform/qt/TemporaryLinkStubsQt.cpp: Copied from WebCore/platform/qt/TemporaryLinkStubs.cpp. + +2010-04-23 Qi Zhang <qi.2.zhang@nokia.com> + + Reviewed by Laszlo Gombos. + + [Qt] LayoutTests/fast/canvas/pointInPath.html passed, actually it failed + https://bugs.webkit.org/show_bug.cgi?id=37276 + + QPainterPath::contains doesn't count the point on the bound. + + * platform/graphics/qt/PathQt.cpp: + (WebCore::isPointOnPathBorder): + (WebCore::Path::contains): + +2010-05-07 Tor Arne Vestbø <tor.arne.vestbo@nokia.com> + + Reviewed by Simon Hausmann. + + [Qt] Fix rendering of -webkit-user-select: none + + -webkit-user-select: none is implemented by filling + the area with an invalid default-constructed Color. + In most ports passing an invalid color down to the + graphics backend seems to produce transparent fills. + + In Qt the behavior of painting with an invalid QColor + is undefined, and in practice it results in painting + black opaque areas. + + One way to fix this would be to use Qt::transparent + when converting an undefined Color to a QColor, but + Qt does not have short circuits for fully transparent + painting, and we actually end up in slow code paths + due to the transparency. So, we're better of doing the + short circuit in WebKit. + + https://bugs.webkit.org/show_bug.cgi?id=38523 + + * platform/graphics/qt/GraphicsContextQt.cpp: + +2010-04-05 Robert Hogan <robert@webkit.org> + + Reviewed by Kenneth Rohde Christiansen. + + [Qt] Fix infinite redirection loop in QNetworkReplyHandler + + Put a maximum on consecutive redirections so we don't have to + worry about whether it's the same url or not. + + Tolerate up to 10 consecutive redirections, anything beyond + that is considered a potentially infinite recursion in the + redirection requests. This is the same behaviour as Firefox. + + https://bugs.webkit.org/show_bug.cgi?id=37097 + + * platform/network/qt/QNetworkReplyHandler.cpp: + (WebCore::QNetworkReplyHandler::QNetworkReplyHandler): + (WebCore::QNetworkReplyHandler::sendResponseIfNeeded): + * platform/network/qt/QNetworkReplyHandler.h: + +2010-04-05 Robert Hogan <robert@webkit.org> + + Reviewed by Kenneth Rohde-Christiansen. + + [Qt] Fix infinite redirection loop in QNetworkReplyHandler + + Qt enters an infinite loop if a redirect response redirects to itself. + + Fixes http/tests/xmlhttprequest/connection-error-sync.html + + https://bugs.webkit.org/show_bug.cgi?id=37097 + + * platform/network/qt/QNetworkReplyHandler.cpp: + (WebCore::QNetworkReplyHandler::sendResponseIfNeeded): + +2010-05-07 Ben Murdoch <benm@google.com> + + Reviewed by Darin Adler. + + Potential crash in EventHandler::handleTouchEvent + https://bugs.webkit.org/show_bug.cgi?id=38646 + + Fix a ref counting bug that can cause a crash if the m_originatingouchPointTargets + hashmap holds the last ref to an EventTarget when the user lifts their finger. + + This is very hard to reproduce in a consistent way and clearly a + simple logic error in the code, therefore no new tests. + + * page/EventHandler.cpp: + (WebCore::EventHandler::handleTouchEvent): Don't let the RefPtr we get back from + the hasmap go out of scope so soon as it could delete the wrapped ptr if the + hashmap held the last ref (and we use the raw ptr that the RefPtr + wraps later in the WebCore::Touch constructor). + +2010-05-04 Ben Murdoch <benm@google.com> + + Reviewed by Simon Hausmann. + + Crash in handleTouchEvent: using dangling node ptrs in hashmap + https://bugs.webkit.org/show_bug.cgi?id=38514 + + When navigating away from a page, if you have your finger still + pressed and then lift it on the new page we see a crash if the + node got deleted as we still have a dangling pointer in the + m_originatingTouchPointTargets hashmap and try to use it as the + receiver to dispatch a touchend event. + + Test: fast/events/touch/touch-stale-node-crash.html + + * page/EventHandler.cpp: + (WebCore::EventHandler::clear): Clear the hashmap of touch targets. + 2010-05-04 Luiz Agostini <luiz.agostini@openbossa.org> Reviewed by Simon Hausmann. diff --git a/src/3rdparty/webkit/WebCore/WebCore.gypi b/src/3rdparty/webkit/WebCore/WebCore.gypi index caa79f292b..94a6052b03 100644 --- a/src/3rdparty/webkit/WebCore/WebCore.gypi +++ b/src/3rdparty/webkit/WebCore/WebCore.gypi @@ -18,10 +18,10 @@ 'css/CSSVariablesDeclaration.idl', 'css/CSSVariablesRule.idl', 'css/Counter.idl', - 'css/Media.idl', 'css/MediaList.idl', - 'css/RGBColor.idl', 'css/Rect.idl', + 'css/RGBColor.idl', + 'css/StyleMedia.idl', 'css/StyleSheet.idl', 'css/StyleSheetList.idl', 'css/WebKitCSSKeyframeRule.idl', @@ -1003,33 +1003,33 @@ 'css/FontValue.h', 'css/MediaFeatureNames.cpp', 'css/MediaFeatureNames.h', - 'css/Media.cpp', - 'css/Media.h', 'css/MediaList.cpp', 'css/MediaList.h', 'css/MediaQuery.cpp', - 'css/MediaQuery.h', 'css/MediaQueryEvaluator.cpp', 'css/MediaQueryEvaluator.h', 'css/MediaQueryExp.cpp', 'css/MediaQueryExp.h', + 'css/MediaQuery.h', 'css/Pair.h', 'css/Rect.h', 'css/RGBColor.cpp', 'css/RGBColor.h', - 'css/SVGCSSComputedStyleDeclaration.cpp', - 'css/SVGCSSParser.cpp', - 'css/SVGCSSStyleSelector.cpp', 'css/ShadowValue.cpp', 'css/ShadowValue.h', 'css/StyleBase.cpp', 'css/StyleBase.h', 'css/StyleList.cpp', 'css/StyleList.h', + 'css/StyleMedia.cpp', + 'css/StyleMedia.h', 'css/StyleSheet.cpp', 'css/StyleSheet.h', 'css/StyleSheetList.cpp', 'css/StyleSheetList.h', + 'css/SVGCSSComputedStyleDeclaration.cpp', + 'css/SVGCSSParser.cpp', + 'css/SVGCSSStyleSelector.cpp', 'css/WebKitCSSKeyframeRule.cpp', 'css/WebKitCSSKeyframeRule.h', 'css/WebKitCSSKeyframesRule.cpp', @@ -2640,7 +2640,7 @@ 'platform/qt/SharedBufferQt.cpp', 'platform/qt/SharedTimerQt.cpp', 'platform/qt/SoundQt.cpp', - 'platform/qt/TemporaryLinkStubs.cpp', + 'platform/qt/TemporaryLinkStubsQt.cpp', 'platform/qt/WheelEventQt.cpp', 'platform/qt/WidgetQt.cpp', 'platform/sql/SQLValue.cpp', @@ -2920,7 +2920,7 @@ 'plugins/gtk/xembed.h', 'plugins/mac/PluginDataMac.mm', 'plugins/mac/PluginPackageMac.cpp', - 'plugins/mac/PluginViewMac.cpp', + 'plugins/mac/PluginViewMac.mm', 'plugins/qt/PluginDataQt.cpp', 'plugins/qt/PluginPackageQt.cpp', 'plugins/qt/PluginViewQt.cpp', diff --git a/src/3rdparty/webkit/WebCore/WebCore.pri b/src/3rdparty/webkit/WebCore/WebCore.pri index ad514a222a..97ae5261c0 100644 --- a/src/3rdparty/webkit/WebCore/WebCore.pri +++ b/src/3rdparty/webkit/WebCore/WebCore.pri @@ -101,18 +101,19 @@ greaterThan(QT_MINOR_VERSION, 5) { DEFINES += ENABLE_XSLT=0 } -!CONFIG(QTDIR_build):!contains(DEFINES, ENABLE_QT_BEARER=.) { - symbian: { - exists($${EPOCROOT}epoc32/release/winscw/udeb/QtBearer.lib)| \ - exists($${EPOCROOT}epoc32/release/armv5/lib/QtBearer.lib) { +# Bearer management is part of Qt 4.7 +# for older version, check for mobility with bearer +!contains(DEFINES, ENABLE_QT_BEARER=.) { + !lessThan(QT_MINOR_VERSION, 7) { + DEFINES += ENABLE_QT_BEARER=1 + } else { + load(mobilityconfig, true) + contains(MOBILITY_CONFIG, bearer) { DEFINES += ENABLE_QT_BEARER=1 } } } -# Bearer management is part of Qt 4.7 -!lessThan(QT_MINOR_VERSION, 7):!contains(DEFINES, ENABLE_QT_BEARER=.):DEFINES += ENABLE_QT_BEARER=1 - # Enable touch event support with Qt 4.6 !lessThan(QT_MINOR_VERSION, 6): DEFINES += ENABLE_TOUCH_EVENTS=1 @@ -227,10 +228,10 @@ IDL_BINDINGS += \ css/CSSValueList.idl \ css/CSSVariablesDeclaration.idl \ css/CSSVariablesRule.idl \ - css/Media.idl \ css/MediaList.idl \ - css/RGBColor.idl \ css/Rect.idl \ + css/RGBColor.idl \ + css/StyleMedia.idl \ css/StyleSheet.idl \ css/StyleSheetList.idl \ css/WebKitCSSKeyframeRule.idl \ @@ -593,6 +594,7 @@ contains(DEFINES, ENABLE_SVG=1) { # GENERATOR 5-C: svgnames.output = $${WC_GENERATED_SOURCES_DIR}/SVGNames.cpp svgnames.input = SVG_NAMES + svgnames.depends = $$PWD/svg/svgattrs.in svgnames.wkScript = $$PWD/dom/make_names.pl svgnames.commands = perl -I$$PWD/bindings/scripts $$svgnames.wkScript --tags $$PWD/svg/svgtags.in --attrs $$PWD/svg/svgattrs.in --extraDefines \"$${DEFINES}\" --preprocessor \"$${QMAKE_MOC} -E\" --factory --wrapperFactory --outputDir $$WC_GENERATED_SOURCES_DIR svgnames.wkExtraSources = $${WC_GENERATED_SOURCES_DIR}/SVGElementFactory.cpp $${WC_GENERATED_SOURCES_DIR}/JSSVGElementWrapperFactory.cpp diff --git a/src/3rdparty/webkit/WebCore/WebCore.pro b/src/3rdparty/webkit/WebCore/WebCore.pro index d6a97a2a28..afb1bcdf7a 100644 --- a/src/3rdparty/webkit/WebCore/WebCore.pro +++ b/src/3rdparty/webkit/WebCore/WebCore.pro @@ -60,7 +60,7 @@ CONFIG(standalone_package) { isEmpty(WC_GENERATED_SOURCES_DIR):WC_GENERATED_SOURCES_DIR = generated isEmpty(JSC_GENERATED_SOURCES_DIR):JSC_GENERATED_SOURCES_DIR = ../JavaScriptCore/generated - CONFIG(debug, debug|release) { + !CONFIG(release, debug|release) { OBJECTS_DIR = obj/debug } else { # Release OBJECTS_DIR = obj/release @@ -75,7 +75,8 @@ CONFIG(QTDIR_build) { !static: DEFINES += QT_MAKEDLL symbian: TARGET =$$TARGET$${QT_LIBINFIX} } -include($$PWD/../WebKit/qt/qtwebkit_version.pri) +moduleFile=$$PWD/../WebKit/qt/qt_webkit_version.pri +include($$moduleFile) VERSION = $${QT_WEBKIT_MAJOR_VERSION}.$${QT_WEBKIT_MINOR_VERSION}.$${QT_WEBKIT_PATCH_VERSION} unix { @@ -103,7 +104,7 @@ win32-msvc2005|win32-msvc2008:{ } # Pick up 3rdparty libraries from INCLUDE/LIB just like with MSVC -win32-g++ { +win32-g++* { TMPPATH = $$quote($$(INCLUDE)) QMAKE_INCDIR_POST += $$split(TMPPATH,";") TMPPATH = $$quote($$(LIB)) @@ -126,7 +127,7 @@ maemo5|symbian|embedded { DEFINES += ENABLE_FAST_MOBILE_SCROLLING=1 } -maemo5 { +maemo5|symbian { DEFINES += WTF_USE_QT_MOBILE_THEME=1 } @@ -160,7 +161,7 @@ defineTest(addExtraCompiler) { for(file,input) { base = $$basename(file) - base ~= s/\..+// + base ~= s/\\..+// newfile=$$replace(outputRule,\\$\\{QMAKE_FILE_BASE\\},$$base) SOURCES += $$newfile } @@ -432,7 +433,6 @@ SOURCES += \ css/FontFamilyValue.cpp \ css/FontValue.cpp \ css/MediaFeatureNames.cpp \ - css/Media.cpp \ css/MediaList.cpp \ css/MediaQuery.cpp \ css/MediaQueryEvaluator.cpp \ @@ -441,6 +441,7 @@ SOURCES += \ css/ShadowValue.cpp \ css/StyleBase.cpp \ css/StyleList.cpp \ + css/StyleMedia.cpp \ css/StyleSheet.cpp \ css/StyleSheetList.cpp \ css/WebKitCSSKeyframeRule.cpp \ @@ -1146,7 +1147,6 @@ HEADERS += \ css/FontFamilyValue.h \ css/FontValue.h \ css/MediaFeatureNames.h \ - css/Media.h \ css/MediaList.h \ css/MediaQueryEvaluator.h \ css/MediaQueryExp.h \ @@ -1155,6 +1155,7 @@ HEADERS += \ css/ShadowValue.h \ css/StyleBase.h \ css/StyleList.h \ + css/StyleMedia.h \ css/StyleSheet.h \ css/StyleSheetList.h \ css/WebKitCSSKeyframeRule.h \ @@ -2082,7 +2083,7 @@ SOURCES += \ platform/qt/SoundQt.cpp \ platform/qt/LoggingQt.cpp \ platform/text/qt/StringQt.cpp \ - platform/qt/TemporaryLinkStubs.cpp \ + platform/qt/TemporaryLinkStubsQt.cpp \ platform/text/qt/TextBoundariesQt.cpp \ platform/text/qt/TextBreakIteratorQt.cpp \ platform/text/qt/TextCodecQt.cpp \ @@ -2166,7 +2167,7 @@ contains(DEFINES, ENABLE_NETSCAPE_PLUGIN_API=1) { mac { SOURCES += \ plugins/mac/PluginPackageMac.cpp \ - plugins/mac/PluginViewMac.cpp + plugins/mac/PluginViewMac.mm OBJECTIVE_SOURCES += \ platform/text/mac/StringImplMac.mm \ platform/mac/WebCoreNSStringExtras.mm @@ -2496,8 +2497,12 @@ contains(DEFINES, ENABLE_QT_BEARER=1) { SOURCES += \ platform/network/qt/NetworkStateNotifierQt.cpp - CONFIG += mobility - MOBILITY += bearer + # Bearer management is part of Qt 4.7, so don't accidentially + # pull in Qt Mobility when building against >= 4.7 + !greaterThan(QT_MINOR_VERSION, 6) { + CONFIG += mobility + MOBILITY += bearer + } } contains(DEFINES, ENABLE_SVG=1) { @@ -2847,18 +2852,34 @@ HEADERS += $$WEBKIT_API_HEADERS !symbian { headers.files = $$WEBKIT_INSTALL_HEADERS - headers.path = $$[QT_INSTALL_HEADERS]/QtWebKit - target.path = $$[QT_INSTALL_LIBS] - INSTALLS += target headers + !isEmpty(INSTALL_HEADERS): headers.path = $$INSTALL_HEADERS/QtWebKit + else: headers.path = $$[QT_INSTALL_HEADERS]/QtWebKit + + !isEmpty(INSTALL_LIBS): target.path = $$INSTALL_LIBS + else: target.path = $$[QT_INSTALL_LIBS] + + modfile.files = $$moduleFile + modfile.path = $$[QMAKE_MKSPECS]/modules + + INSTALLS += target headers modfile } else { # INSTALLS is not implemented in qmake's s60 generators, copy headers manually inst_headers.commands = $$QMAKE_COPY ${QMAKE_FILE_NAME} ${QMAKE_FILE_OUT} inst_headers.input = WEBKIT_INSTALL_HEADERS - inst_headers.output = $$[QT_INSTALL_HEADERS]/QtWebKit/${QMAKE_FILE_BASE}${QMAKE_FILE_EXT} + + !isEmpty(INSTALL_HEADERS): inst_headers.output = $$INSTALL_HEADERS/QtWebKit/${QMAKE_FILE_BASE}${QMAKE_FILE_EXT} + else: inst_headers.output = $$[QT_INSTALL_HEADERS]/QtWebKit/${QMAKE_FILE_BASE}${QMAKE_FILE_EXT} + QMAKE_EXTRA_COMPILERS += inst_headers - install.depends += compiler_inst_headers_make_all + inst_modfile.commands = $$inst_headers.commands + inst_modfile.input = moduleFile + inst_modfile.output = $$[QMAKE_MKSPECS]/modules + + QMAKE_EXTRA_COMPILERS += inst_modfile + + install.depends += compiler_inst_headers_make_all compiler_inst_modfile_make_all QMAKE_EXTRA_TARGETS += install } @@ -2876,7 +2897,7 @@ HEADERS += $$WEBKIT_API_HEADERS QMAKE_PKGCONFIG_LIBDIR = $$target.path QMAKE_PKGCONFIG_INCDIR = $$headers.path QMAKE_PKGCONFIG_DESTDIR = pkgconfig - lib_replace.match = $$DESTDIR + lib_replace.match = $$re_escape($$DESTDIR) lib_replace.replace = $$[QT_INSTALL_LIBS] QMAKE_PKGCONFIG_INSTALL_REPLACE += lib_replace } @@ -2910,7 +2931,7 @@ CONFIG(QTDIR_build) { CONFIG += no_debug_info } -!win32-g++:win32:contains(QMAKE_HOST.arch, x86_64):{ +win32:!win32-g++*:contains(QMAKE_HOST.arch, x86_64):{ asm_compiler.commands = ml64 /c asm_compiler.commands += /Fo ${QMAKE_FILE_OUT} ${QMAKE_FILE_IN} asm_compiler.output = ${QMAKE_VAR_OBJECTS_DIR}${QMAKE_FILE_BASE}$${first(QMAKE_EXT_OBJ)} diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp index a27192305e..0254d0fea6 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp @@ -361,6 +361,24 @@ JSValue JSCanvasRenderingContext2D::createPattern(ExecState* exec, const ArgList return jsUndefined(); } +JSValue JSCanvasRenderingContext2D::createImageData(ExecState* exec, const ArgList& args) +{ + // createImageData has two variants + // createImageData(ImageData) + // createImageData(width, height) + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); + RefPtr<ImageData> imageData = 0; + + ExceptionCode ec = 0; + if (args.size() == 1) + imageData = context->createImageData(toImageData(args.at(0)), ec); + else if (args.size() == 2) + imageData = context->createImageData(args.at(0).toFloat(exec), args.at(1).toFloat(exec), ec); + + setDOMException(exec, ec); + return toJS(exec, globalObject(), WTF::getPtr(imageData)); +} + JSValue JSCanvasRenderingContext2D::putImageData(ExecState* exec, const ArgList& args) { // putImageData has two variants diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp index 4d5de79650..61785092bf 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp @@ -77,7 +77,7 @@ bool JSCustomSQLStatementErrorCallback::handleEvent(SQLTransaction* transaction, // Therefore an exception and returning true are the same thing - so, return true on an exception return true; } - return !result.isFalse(); + return result.toBoolean(exec); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp index 80634f7c57..8f241f9b56 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp @@ -78,7 +78,10 @@ JSValue JSHTMLCanvasElement::getContext(ExecState* exec, const ArgList& args) } } #endif - return toJS(exec, globalObject(), WTF::getPtr(canvas->getContext(contextId, attrs.get()))); + CanvasRenderingContext* context = canvas->getContext(contextId, attrs.get()); + if (!context) + return jsNull(); + return toJS(exec, globalObject(), WTF::getPtr(context)); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bridge/qt/qt_class.cpp b/src/3rdparty/webkit/WebCore/bridge/qt/qt_class.cpp index cfd74d9388..2e1f6e6dd7 100644 --- a/src/3rdparty/webkit/WebCore/bridge/qt/qt_class.cpp +++ b/src/3rdparty/webkit/WebCore/bridge/qt/qt_class.cpp @@ -98,10 +98,12 @@ JSValue QtClass::fallbackObject(ExecState* exec, Instance* inst, const Identifie if (m.access() == QMetaMethod::Private) continue; - QByteArray signature = m.signature(); - signature.truncate(signature.indexOf('(')); + int iter = 0; + const char* signature = m.signature(); + while (signature[iter] && signature[iter] != '(') + ++iter; - if (normal == signature) { + if (normal == QByteArray::fromRawData(signature, iter)) { QtRuntimeMetaMethod* val = new (exec) QtRuntimeMetaMethod(exec, identifier, static_cast<QtInstance*>(inst), index, normal, false); qtinst->m_methods.insert(name, val); return val; diff --git a/src/3rdparty/webkit/WebCore/bridge/qt/qt_instance.cpp b/src/3rdparty/webkit/WebCore/bridge/qt/qt_instance.cpp index f6f368be80..d40ab0b716 100644 --- a/src/3rdparty/webkit/WebCore/bridge/qt/qt_instance.cpp +++ b/src/3rdparty/webkit/WebCore/bridge/qt/qt_instance.cpp @@ -287,7 +287,7 @@ JSValue QtInstance::stringValue(ExecState* exec) const void * qargs[1]; qargs[0] = ret.data(); - if (obj->qt_metacall(QMetaObject::InvokeMetaMethod, index, qargs) < 0) { + if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, qargs) < 0) { if (ret.isValid() && ret.canConvert(QVariant::String)) { buf = ret.toString().toLatin1().constData(); // ### Latin 1? Ascii? useDefault = false; diff --git a/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.cpp b/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.cpp index 803316d78f..3e6197f0af 100644 --- a/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.cpp +++ b/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.cpp @@ -346,10 +346,17 @@ returnEmptyVariant: return QVariant::fromValue<QImage>(QImage()); return QVariant(); } -JSObject* QtPixmapInstance::createRuntimeObject(ExecState* exec, PassRefPtr<RootObject> root, const QVariant& data) + +RuntimeObject* QtPixmapInstance::newRuntimeObject(ExecState* exec) +{ + return new(exec) QtPixmapRuntimeObject(exec, this); +} + +JSObject* QtPixmapInstance::createPixmapRuntimeObject(ExecState* exec, PassRefPtr<RootObject> root, const QVariant& data) { JSLock lock(SilenceAssertionsOnly); - return new(exec) QtPixmapRuntimeObject(exec, new QtPixmapInstance(root, data)); + QtPixmapInstance* instance = new QtPixmapInstance(root, data); + return instance->createRuntimeObject(exec); } bool QtPixmapInstance::canHandle(QMetaType::Type hint) diff --git a/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.h b/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.h index a0e0e26849..de1bcee86e 100644 --- a/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.h +++ b/src/3rdparty/webkit/WebCore/bridge/qt/qt_pixmapruntime.h @@ -42,7 +42,8 @@ public: int height() const; QPixmap toPixmap(); QImage toImage(); - static JSObject* createRuntimeObject(ExecState*, PassRefPtr<RootObject>, const QVariant&); + RuntimeObject* newRuntimeObject(ExecState* exec); + static JSObject* createPixmapRuntimeObject(ExecState*, PassRefPtr<RootObject>, const QVariant&); static QVariant variantFromObject(JSObject*, QMetaType::Type hint); static bool canHandle(QMetaType::Type hint); }; diff --git a/src/3rdparty/webkit/WebCore/bridge/qt/qt_runtime.cpp b/src/3rdparty/webkit/WebCore/bridge/qt/qt_runtime.cpp index 17758154a9..a39dc7a4de 100644 --- a/src/3rdparty/webkit/WebCore/bridge/qt/qt_runtime.cpp +++ b/src/3rdparty/webkit/WebCore/bridge/qt/qt_runtime.cpp @@ -877,7 +877,7 @@ JSValue convertQVariantToValue(ExecState* exec, PassRefPtr<RootObject> root, con } if (QtPixmapInstance::canHandle(static_cast<QMetaType::Type>(variant.type()))) - return QtPixmapInstance::createRuntimeObject(exec, root, variant); + return QtPixmapInstance::createPixmapRuntimeObject(exec, root, variant); if (type == qMetaTypeId<QWebElement>()) { if (!root->globalObject()->inherits(&JSDOMWindow::s_info)) @@ -1397,7 +1397,7 @@ JSValue QtRuntimeMetaMethod::call(ExecState* exec, JSObject* functionObject, JSV int methodIndex; JSObject* errorObj = 0; if ((methodIndex = findMethodIndex(exec, obj->metaObject(), d->m_signature, d->m_allowPrivate, args, vargs, (void **)qargs, &errorObj)) != -1) { - if (obj->qt_metacall(QMetaObject::InvokeMetaMethod, methodIndex, qargs) >= 0) + if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, methodIndex, qargs) >= 0) return jsUndefined(); if (vargs[0].isValid()) diff --git a/src/3rdparty/webkit/WebCore/css/CSSParser.cpp b/src/3rdparty/webkit/WebCore/css/CSSParser.cpp index 214fc5149f..a5a8b5ccff 100644 --- a/src/3rdparty/webkit/WebCore/css/CSSParser.cpp +++ b/src/3rdparty/webkit/WebCore/css/CSSParser.cpp @@ -279,7 +279,6 @@ bool CSSParser::parseValue(CSSMutableStyleDeclaration* declaration, int id, cons // possible to set up a default color. bool CSSParser::parseColor(RGBA32& color, const String& string, bool strict) { - color = 0; CSSParser parser(true); // First try creating a color specified by name or the "#" syntax. diff --git a/src/3rdparty/webkit/WebCore/css/Media.cpp b/src/3rdparty/webkit/WebCore/css/StyleMedia.cpp index e238602c90..6cb662fcff 100644 --- a/src/3rdparty/webkit/WebCore/css/Media.cpp +++ b/src/3rdparty/webkit/WebCore/css/StyleMedia.cpp @@ -24,8 +24,8 @@ */ #include "config.h" +#include "StyleMedia.h" -#include "Media.h" #include "CSSStyleSelector.h" #include "Frame.h" #include "FrameView.h" @@ -34,12 +34,12 @@ namespace WebCore { -Media::Media(Frame* frame) +StyleMedia::StyleMedia(Frame* frame) : m_frame(frame) { } -String Media::type() const +String StyleMedia::type() const { FrameView* view = m_frame ? m_frame->view() : 0; if (view) @@ -48,7 +48,7 @@ String Media::type() const return String(); } -bool Media::matchMedium(const String& query) const +bool StyleMedia::matchMedium(const String& query) const { if (!m_frame) return false; diff --git a/src/3rdparty/webkit/WebCore/css/Media.h b/src/3rdparty/webkit/WebCore/css/StyleMedia.h index ee6961b368..761e6a3755 100644 --- a/src/3rdparty/webkit/WebCore/css/Media.h +++ b/src/3rdparty/webkit/WebCore/css/StyleMedia.h @@ -1,5 +1,6 @@ /* * Copyright (C) 2009 Apple Inc. All rights reserved. + * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -23,18 +24,18 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef Media_h -#define Media_h +#ifndef StyleMedia_h +#define StyleMedia_h #include "DOMWindow.h" namespace WebCore { -class Media : public RefCounted<Media> { +class StyleMedia : public RefCounted<StyleMedia> { public: - static PassRefPtr<Media> create(Frame* frame) + static PassRefPtr<StyleMedia> create(Frame* frame) { - return adoptRef(new Media(frame)); + return adoptRef(new StyleMedia(frame)); } void disconnectFrame() { m_frame = 0; } @@ -42,13 +43,13 @@ public: String type() const; bool matchMedium(const String&) const; - + private: - Media(Frame*); + StyleMedia(Frame*); Frame* m_frame; }; } // namespace -#endif // Media_h +#endif // StyleMedia_h diff --git a/src/3rdparty/webkit/WebCore/css/Media.idl b/src/3rdparty/webkit/WebCore/css/StyleMedia.idl index 1bf59007b8..7be35cc60f 100644 --- a/src/3rdparty/webkit/WebCore/css/Media.idl +++ b/src/3rdparty/webkit/WebCore/css/StyleMedia.idl @@ -1,5 +1,6 @@ /* * Copyright (C) 2009 Apple Inc. All rights reserved. + * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -24,7 +25,7 @@ */ module view { - interface Media { + interface StyleMedia { readonly attribute DOMString type; boolean matchMedium(in DOMString mediaquery); }; diff --git a/src/3rdparty/webkit/WebCore/editing/ApplyStyleCommand.cpp b/src/3rdparty/webkit/WebCore/editing/ApplyStyleCommand.cpp index 1c739ec5f7..529d9d37c4 100644 --- a/src/3rdparty/webkit/WebCore/editing/ApplyStyleCommand.cpp +++ b/src/3rdparty/webkit/WebCore/editing/ApplyStyleCommand.cpp @@ -212,7 +212,7 @@ void StyleChange::extractTextStyles(CSSMutableStyleDeclaration* style) if (RefPtr<CSSValue> colorValue = style->getPropertyCSSValue(CSSPropertyColor)) { ASSERT(colorValue->isPrimitiveValue()); CSSPrimitiveValue* primitiveColor = static_cast<CSSPrimitiveValue*>(colorValue.get()); - RGBA32 rgba; + RGBA32 rgba = 0; if (primitiveColor->primitiveType() != CSSPrimitiveValue::CSS_RGBCOLOR) { CSSParser::parseColor(rgba, colorValue->cssText()); // Need to take care of named color such as green and black diff --git a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp index a991e8d018..d97b54a5f7 100644 --- a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp +++ b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp @@ -165,7 +165,7 @@ static const HashTableValue JSCanvasRenderingContext2DPrototypeTableValues[45] = { "drawImageFromRect", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionDrawImageFromRect), (intptr_t)0 }, { "setShadow", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetShadow), (intptr_t)0 }, { "createPattern", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreatePattern), (intptr_t)0 }, - { "createImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateImageData), (intptr_t)2 }, + { "createImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateImageData), (intptr_t)0 }, { "getImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionGetImageData), (intptr_t)4 }, { "putImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionPutImageData), (intptr_t)0 }, { 0, 0, 0, 0 } @@ -1018,15 +1018,7 @@ JSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionCreateImageData if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info)) return throwError(exec, TypeError); JSCanvasRenderingContext2D* castedThisObj = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue)); - CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThisObj->impl()); - ExceptionCode ec = 0; - float sw = args.at(0).toFloat(exec); - float sh = args.at(1).toFloat(exec); - - - JSC::JSValue result = toJS(exec, castedThisObj->globalObject(), WTF::getPtr(imp->createImageData(sw, sh, ec))); - setDOMException(exec, ec); - return result; + return castedThisObj->createImageData(exec, args); } JSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionGetImageData(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) diff --git a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h index 218e455be5..92fabb7702 100644 --- a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h +++ b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h @@ -61,6 +61,7 @@ public: JSC::JSValue drawImageFromRect(JSC::ExecState*, const JSC::ArgList&); JSC::JSValue setShadow(JSC::ExecState*, const JSC::ArgList&); JSC::JSValue createPattern(JSC::ExecState*, const JSC::ArgList&); + JSC::JSValue createImageData(JSC::ExecState*, const JSC::ArgList&); JSC::JSValue putImageData(JSC::ExecState*, const JSC::ArgList&); protected: static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags; diff --git a/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.cpp b/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.cpp index 04238bcfd9..11dfd2e591 100644 --- a/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.cpp +++ b/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.cpp @@ -152,7 +152,6 @@ #include "JSHTMLVideoElement.h" #include "JSImageData.h" #include "JSKeyboardEvent.h" -#include "JSMedia.h" #include "JSMediaError.h" #include "JSMediaList.h" #include "JSMessageChannel.h" @@ -299,6 +298,7 @@ #include "JSSharedWorker.h" #include "JSStorage.h" #include "JSStorageEvent.h" +#include "JSStyleMedia.h" #include "JSStyleSheet.h" #include "JSStyleSheetList.h" #include "JSText.h" @@ -334,11 +334,11 @@ #include "JSXPathResult.h" #include "JSXSLTProcessor.h" #include "KURL.h" -#include "Media.h" #include "Navigator.h" #include "RegisteredEventListener.h" #include "Screen.h" #include "Storage.h" +#include "StyleMedia.h" #include "WebKitPoint.h" #include <runtime/Error.h> #include <runtime/JSNumberCell.h> @@ -395,7 +395,7 @@ static const HashTableValue JSDOMWindowTableValues[409] = { "parent", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowParent), (intptr_t)setJSDOMWindowParent }, { "top", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTop), (intptr_t)setJSDOMWindowTop }, { "document", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDocument), (intptr_t)0 }, - { "media", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMedia), (intptr_t)0 }, + { "styleMedia", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStyleMedia), (intptr_t)0 }, { "devicePixelRatio", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDevicePixelRatio), (intptr_t)setJSDOMWindowDevicePixelRatio }, { "applicationCache", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowApplicationCache), (intptr_t)0 }, { "sessionStorage", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSessionStorage), (intptr_t)0 }, @@ -1304,14 +1304,14 @@ JSValue jsDOMWindowDocument(ExecState* exec, JSValue slotBase, const Identifier& return result; } -JSValue jsDOMWindowMedia(ExecState* exec, JSValue slotBase, const Identifier&) +JSValue jsDOMWindowStyleMedia(ExecState* exec, JSValue slotBase, const Identifier&) { JSDOMWindow* castedThis = static_cast<JSDOMWindow*>(asObject(slotBase)); if (!castedThis->allowsAccessFrom(exec)) return jsUndefined(); UNUSED_PARAM(exec); DOMWindow* imp = static_cast<DOMWindow*>(castedThis->impl()); - JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->media())); + JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->styleMedia())); return result; } diff --git a/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.h b/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.h index a6f325305c..7e50556deb 100644 --- a/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.h +++ b/src/3rdparty/webkit/WebCore/generated/JSDOMWindow.h @@ -231,7 +231,7 @@ void setJSDOMWindowParent(JSC::ExecState*, JSC::JSObject*, JSC::JSValue); JSC::JSValue jsDOMWindowTop(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); void setJSDOMWindowTop(JSC::ExecState*, JSC::JSObject*, JSC::JSValue); JSC::JSValue jsDOMWindowDocument(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); -JSC::JSValue jsDOMWindowMedia(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); +JSC::JSValue jsDOMWindowStyleMedia(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); JSC::JSValue jsDOMWindowDevicePixelRatio(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); void setJSDOMWindowDevicePixelRatio(JSC::ExecState*, JSC::JSObject*, JSC::JSValue); JSC::JSValue jsDOMWindowApplicationCache(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); diff --git a/src/3rdparty/webkit/WebCore/generated/JSMedia.cpp b/src/3rdparty/webkit/WebCore/generated/JSMedia.cpp deleted file mode 100644 index 1579c2b8f1..0000000000 --- a/src/3rdparty/webkit/WebCore/generated/JSMedia.cpp +++ /dev/null @@ -1,201 +0,0 @@ -/* - This file is part of the WebKit open source project. - This file has been generated by generate-bindings.pl. DO NOT MODIFY! - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with this library; see the file COPYING.LIB. If not, write to - the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#include "config.h" -#include "JSMedia.h" - -#include "KURL.h" -#include "Media.h" -#include <runtime/Error.h> -#include <runtime/JSString.h> -#include <wtf/GetPtr.h> - -using namespace JSC; - -namespace WebCore { - -ASSERT_CLASS_FITS_IN_CELL(JSMedia); - -/* Hash table */ - -static const HashTableValue JSMediaTableValues[3] = -{ - { "type", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsMediaType), (intptr_t)0 }, - { "constructor", DontEnum|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsMediaConstructor), (intptr_t)0 }, - { 0, 0, 0, 0 } -}; - -static JSC_CONST_HASHTABLE HashTable JSMediaTable = -#if ENABLE(PERFECT_HASH_SIZE) - { 3, JSMediaTableValues, 0 }; -#else - { 4, 3, JSMediaTableValues, 0 }; -#endif - -/* Hash table for constructor */ - -static const HashTableValue JSMediaConstructorTableValues[1] = -{ - { 0, 0, 0, 0 } -}; - -static JSC_CONST_HASHTABLE HashTable JSMediaConstructorTable = -#if ENABLE(PERFECT_HASH_SIZE) - { 0, JSMediaConstructorTableValues, 0 }; -#else - { 1, 0, JSMediaConstructorTableValues, 0 }; -#endif - -class JSMediaConstructor : public DOMConstructorObject { -public: - JSMediaConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) - : DOMConstructorObject(JSMediaConstructor::createStructure(globalObject->objectPrototype()), globalObject) - { - putDirect(exec->propertyNames().prototype, JSMediaPrototype::self(exec, globalObject), None); - } - virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&); - virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&); - virtual const ClassInfo* classInfo() const { return &s_info; } - static const ClassInfo s_info; - - static PassRefPtr<Structure> createStructure(JSValue proto) - { - return Structure::create(proto, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount); - } - -protected: - static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | DOMConstructorObject::StructureFlags; -}; - -const ClassInfo JSMediaConstructor::s_info = { "MediaConstructor", 0, &JSMediaConstructorTable, 0 }; - -bool JSMediaConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) -{ - return getStaticValueSlot<JSMediaConstructor, DOMObject>(exec, &JSMediaConstructorTable, this, propertyName, slot); -} - -bool JSMediaConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) -{ - return getStaticValueDescriptor<JSMediaConstructor, DOMObject>(exec, &JSMediaConstructorTable, this, propertyName, descriptor); -} - -/* Hash table for prototype */ - -static const HashTableValue JSMediaPrototypeTableValues[2] = -{ - { "matchMedium", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsMediaPrototypeFunctionMatchMedium), (intptr_t)1 }, - { 0, 0, 0, 0 } -}; - -static JSC_CONST_HASHTABLE HashTable JSMediaPrototypeTable = -#if ENABLE(PERFECT_HASH_SIZE) - { 0, JSMediaPrototypeTableValues, 0 }; -#else - { 2, 1, JSMediaPrototypeTableValues, 0 }; -#endif - -const ClassInfo JSMediaPrototype::s_info = { "MediaPrototype", 0, &JSMediaPrototypeTable, 0 }; - -JSObject* JSMediaPrototype::self(ExecState* exec, JSGlobalObject* globalObject) -{ - return getDOMPrototype<JSMedia>(exec, globalObject); -} - -bool JSMediaPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) -{ - return getStaticFunctionSlot<JSObject>(exec, &JSMediaPrototypeTable, this, propertyName, slot); -} - -bool JSMediaPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) -{ - return getStaticFunctionDescriptor<JSObject>(exec, &JSMediaPrototypeTable, this, propertyName, descriptor); -} - -const ClassInfo JSMedia::s_info = { "Media", 0, &JSMediaTable, 0 }; - -JSMedia::JSMedia(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<Media> impl) - : DOMObjectWithGlobalPointer(structure, globalObject) - , m_impl(impl) -{ -} - -JSMedia::~JSMedia() -{ - forgetDOMObject(this, impl()); -} - -JSObject* JSMedia::createPrototype(ExecState* exec, JSGlobalObject* globalObject) -{ - return new (exec) JSMediaPrototype(JSMediaPrototype::createStructure(globalObject->objectPrototype())); -} - -bool JSMedia::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) -{ - return getStaticValueSlot<JSMedia, Base>(exec, &JSMediaTable, this, propertyName, slot); -} - -bool JSMedia::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) -{ - return getStaticValueDescriptor<JSMedia, Base>(exec, &JSMediaTable, this, propertyName, descriptor); -} - -JSValue jsMediaType(ExecState* exec, JSValue slotBase, const Identifier&) -{ - JSMedia* castedThis = static_cast<JSMedia*>(asObject(slotBase)); - UNUSED_PARAM(exec); - Media* imp = static_cast<Media*>(castedThis->impl()); - JSValue result = jsString(exec, imp->type()); - return result; -} - -JSValue jsMediaConstructor(ExecState* exec, JSValue slotBase, const Identifier&) -{ - JSMedia* domObject = static_cast<JSMedia*>(asObject(slotBase)); - return JSMedia::getConstructor(exec, domObject->globalObject()); -} -JSValue JSMedia::getConstructor(ExecState* exec, JSGlobalObject* globalObject) -{ - return getDOMConstructor<JSMediaConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject)); -} - -JSValue JSC_HOST_CALL jsMediaPrototypeFunctionMatchMedium(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) -{ - UNUSED_PARAM(args); - if (!thisValue.inherits(&JSMedia::s_info)) - return throwError(exec, TypeError); - JSMedia* castedThisObj = static_cast<JSMedia*>(asObject(thisValue)); - Media* imp = static_cast<Media*>(castedThisObj->impl()); - const UString& mediaquery = args.at(0).toString(exec); - - - JSC::JSValue result = jsBoolean(imp->matchMedium(mediaquery)); - return result; -} - -JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, Media* object) -{ - return getDOMObjectWrapper<JSMedia>(exec, globalObject, object); -} -Media* toMedia(JSC::JSValue value) -{ - return value.inherits(&JSMedia::s_info) ? static_cast<JSMedia*>(asObject(value))->impl() : 0; -} - -} diff --git a/src/3rdparty/webkit/WebCore/generated/JSStyleMedia.cpp b/src/3rdparty/webkit/WebCore/generated/JSStyleMedia.cpp new file mode 100644 index 0000000000..b06bf09279 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/generated/JSStyleMedia.cpp @@ -0,0 +1,201 @@ +/* + This file is part of the WebKit open source project. + This file has been generated by generate-bindings.pl. DO NOT MODIFY! + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "config.h" +#include "JSStyleMedia.h" + +#include "KURL.h" +#include "StyleMedia.h" +#include <runtime/Error.h> +#include <runtime/JSString.h> +#include <wtf/GetPtr.h> + +using namespace JSC; + +namespace WebCore { + +ASSERT_CLASS_FITS_IN_CELL(JSStyleMedia); + +/* Hash table */ + +static const HashTableValue JSStyleMediaTableValues[3] = +{ + { "type", DontDelete|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsStyleMediaType), (intptr_t)0 }, + { "constructor", DontEnum|ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsStyleMediaConstructor), (intptr_t)0 }, + { 0, 0, 0, 0 } +}; + +static JSC_CONST_HASHTABLE HashTable JSStyleMediaTable = +#if ENABLE(PERFECT_HASH_SIZE) + { 3, JSStyleMediaTableValues, 0 }; +#else + { 4, 3, JSStyleMediaTableValues, 0 }; +#endif + +/* Hash table for constructor */ + +static const HashTableValue JSStyleMediaConstructorTableValues[1] = +{ + { 0, 0, 0, 0 } +}; + +static JSC_CONST_HASHTABLE HashTable JSStyleMediaConstructorTable = +#if ENABLE(PERFECT_HASH_SIZE) + { 0, JSStyleMediaConstructorTableValues, 0 }; +#else + { 1, 0, JSStyleMediaConstructorTableValues, 0 }; +#endif + +class JSStyleMediaConstructor : public DOMConstructorObject { +public: + JSStyleMediaConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSStyleMediaConstructor::createStructure(globalObject->objectPrototype()), globalObject) + { + putDirect(exec->propertyNames().prototype, JSStyleMediaPrototype::self(exec, globalObject), None); + } + virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&); + virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&); + virtual const ClassInfo* classInfo() const { return &s_info; } + static const ClassInfo s_info; + + static PassRefPtr<Structure> createStructure(JSValue proto) + { + return Structure::create(proto, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount); + } + +protected: + static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | DOMConstructorObject::StructureFlags; +}; + +const ClassInfo JSStyleMediaConstructor::s_info = { "StyleMediaConstructor", 0, &JSStyleMediaConstructorTable, 0 }; + +bool JSStyleMediaConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) +{ + return getStaticValueSlot<JSStyleMediaConstructor, DOMObject>(exec, &JSStyleMediaConstructorTable, this, propertyName, slot); +} + +bool JSStyleMediaConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return getStaticValueDescriptor<JSStyleMediaConstructor, DOMObject>(exec, &JSStyleMediaConstructorTable, this, propertyName, descriptor); +} + +/* Hash table for prototype */ + +static const HashTableValue JSStyleMediaPrototypeTableValues[2] = +{ + { "matchMedium", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsStyleMediaPrototypeFunctionMatchMedium), (intptr_t)1 }, + { 0, 0, 0, 0 } +}; + +static JSC_CONST_HASHTABLE HashTable JSStyleMediaPrototypeTable = +#if ENABLE(PERFECT_HASH_SIZE) + { 0, JSStyleMediaPrototypeTableValues, 0 }; +#else + { 2, 1, JSStyleMediaPrototypeTableValues, 0 }; +#endif + +const ClassInfo JSStyleMediaPrototype::s_info = { "StyleMediaPrototype", 0, &JSStyleMediaPrototypeTable, 0 }; + +JSObject* JSStyleMediaPrototype::self(ExecState* exec, JSGlobalObject* globalObject) +{ + return getDOMPrototype<JSStyleMedia>(exec, globalObject); +} + +bool JSStyleMediaPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) +{ + return getStaticFunctionSlot<JSObject>(exec, &JSStyleMediaPrototypeTable, this, propertyName, slot); +} + +bool JSStyleMediaPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return getStaticFunctionDescriptor<JSObject>(exec, &JSStyleMediaPrototypeTable, this, propertyName, descriptor); +} + +const ClassInfo JSStyleMedia::s_info = { "StyleMedia", 0, &JSStyleMediaTable, 0 }; + +JSStyleMedia::JSStyleMedia(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<StyleMedia> impl) + : DOMObjectWithGlobalPointer(structure, globalObject) + , m_impl(impl) +{ +} + +JSStyleMedia::~JSStyleMedia() +{ + forgetDOMObject(this, impl()); +} + +JSObject* JSStyleMedia::createPrototype(ExecState* exec, JSGlobalObject* globalObject) +{ + return new (exec) JSStyleMediaPrototype(JSStyleMediaPrototype::createStructure(globalObject->objectPrototype())); +} + +bool JSStyleMedia::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) +{ + return getStaticValueSlot<JSStyleMedia, Base>(exec, &JSStyleMediaTable, this, propertyName, slot); +} + +bool JSStyleMedia::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return getStaticValueDescriptor<JSStyleMedia, Base>(exec, &JSStyleMediaTable, this, propertyName, descriptor); +} + +JSValue jsStyleMediaType(ExecState* exec, JSValue slotBase, const Identifier&) +{ + JSStyleMedia* castedThis = static_cast<JSStyleMedia*>(asObject(slotBase)); + UNUSED_PARAM(exec); + StyleMedia* imp = static_cast<StyleMedia*>(castedThis->impl()); + JSValue result = jsString(exec, imp->type()); + return result; +} + +JSValue jsStyleMediaConstructor(ExecState* exec, JSValue slotBase, const Identifier&) +{ + JSStyleMedia* domObject = static_cast<JSStyleMedia*>(asObject(slotBase)); + return JSStyleMedia::getConstructor(exec, domObject->globalObject()); +} +JSValue JSStyleMedia::getConstructor(ExecState* exec, JSGlobalObject* globalObject) +{ + return getDOMConstructor<JSStyleMediaConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject)); +} + +JSValue JSC_HOST_CALL jsStyleMediaPrototypeFunctionMatchMedium(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) +{ + UNUSED_PARAM(args); + if (!thisValue.inherits(&JSStyleMedia::s_info)) + return throwError(exec, TypeError); + JSStyleMedia* castedThisObj = static_cast<JSStyleMedia*>(asObject(thisValue)); + StyleMedia* imp = static_cast<StyleMedia*>(castedThisObj->impl()); + const UString& mediaquery = args.at(0).toString(exec); + + + JSC::JSValue result = jsBoolean(imp->matchMedium(mediaquery)); + return result; +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, StyleMedia* object) +{ + return getDOMObjectWrapper<JSStyleMedia>(exec, globalObject, object); +} +StyleMedia* toStyleMedia(JSC::JSValue value) +{ + return value.inherits(&JSStyleMedia::s_info) ? static_cast<JSStyleMedia*>(asObject(value))->impl() : 0; +} + +} diff --git a/src/3rdparty/webkit/WebCore/generated/JSMedia.h b/src/3rdparty/webkit/WebCore/generated/JSStyleMedia.h index 28515c9802..12601d54da 100644 --- a/src/3rdparty/webkit/WebCore/generated/JSMedia.h +++ b/src/3rdparty/webkit/WebCore/generated/JSStyleMedia.h @@ -18,8 +18,8 @@ Boston, MA 02110-1301, USA. */ -#ifndef JSMedia_h -#define JSMedia_h +#ifndef JSStyleMedia_h +#define JSStyleMedia_h #include "JSDOMBinding.h" #include <runtime/JSGlobalObject.h> @@ -27,13 +27,13 @@ namespace WebCore { -class Media; +class StyleMedia; -class JSMedia : public DOMObjectWithGlobalPointer { +class JSStyleMedia : public DOMObjectWithGlobalPointer { typedef DOMObjectWithGlobalPointer Base; public: - JSMedia(NonNullPassRefPtr<JSC::Structure>, JSDOMGlobalObject*, PassRefPtr<Media>); - virtual ~JSMedia(); + JSStyleMedia(NonNullPassRefPtr<JSC::Structure>, JSDOMGlobalObject*, PassRefPtr<StyleMedia>); + virtual ~JSStyleMedia(); static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*); virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&); virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&); @@ -46,18 +46,18 @@ public: } static JSC::JSValue getConstructor(JSC::ExecState*, JSC::JSGlobalObject*); - Media* impl() const { return m_impl.get(); } + StyleMedia* impl() const { return m_impl.get(); } private: - RefPtr<Media> m_impl; + RefPtr<StyleMedia> m_impl; protected: static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags; }; -JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, Media*); -Media* toMedia(JSC::JSValue); +JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, StyleMedia*); +StyleMedia* toStyleMedia(JSC::JSValue); -class JSMediaPrototype : public JSC::JSObject { +class JSStyleMediaPrototype : public JSC::JSObject { typedef JSC::JSObject Base; public: static JSC::JSObject* self(JSC::ExecState*, JSC::JSGlobalObject*); @@ -69,18 +69,18 @@ public: { return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount); } - JSMediaPrototype(NonNullPassRefPtr<JSC::Structure> structure) : JSC::JSObject(structure) { } + JSStyleMediaPrototype(NonNullPassRefPtr<JSC::Structure> structure) : JSC::JSObject(structure) { } protected: static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags; }; // Functions -JSC::JSValue JSC_HOST_CALL jsMediaPrototypeFunctionMatchMedium(JSC::ExecState*, JSC::JSObject*, JSC::JSValue, const JSC::ArgList&); +JSC::JSValue JSC_HOST_CALL jsStyleMediaPrototypeFunctionMatchMedium(JSC::ExecState*, JSC::JSObject*, JSC::JSValue, const JSC::ArgList&); // Attributes -JSC::JSValue jsMediaType(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); -JSC::JSValue jsMediaConstructor(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); +JSC::JSValue jsStyleMediaType(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); +JSC::JSValue jsStyleMediaConstructor(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&); } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp b/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp index 30a620cd04..0c5159dea6 100644 --- a/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp +++ b/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp @@ -143,10 +143,12 @@ String HTMLCanvasElement::toDataURL(const String& mimeType, ExceptionCode& ec) if (m_size.isEmpty() || !buffer()) return String("data:,"); - if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType)) + String lowercaseMimeType = mimeType.lower(); + + if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType)) return buffer()->toDataURL("image/png"); - return buffer()->toDataURL(mimeType); + return buffer()->toDataURL(lowercaseMimeType); } CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs) diff --git a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp index 8add19cc94..9cec7a92b1 100644 --- a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp +++ b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp @@ -209,7 +209,7 @@ float CanvasRenderingContext2D::lineWidth() const void CanvasRenderingContext2D::setLineWidth(float width) { - if (!(width > 0)) + if (!(isfinite(width) && width > 0)) return; state().m_lineWidth = width; GraphicsContext* c = drawingContext(); @@ -259,7 +259,7 @@ float CanvasRenderingContext2D::miterLimit() const void CanvasRenderingContext2D::setMiterLimit(float limit) { - if (!(limit > 0)) + if (!(isfinite(limit) && limit > 0)) return; state().m_miterLimit = limit; GraphicsContext* c = drawingContext(); @@ -275,6 +275,8 @@ float CanvasRenderingContext2D::shadowOffsetX() const void CanvasRenderingContext2D::setShadowOffsetX(float x) { + if (!isfinite(x)) + return; state().m_shadowOffset.setWidth(x); applyShadow(); } @@ -286,6 +288,8 @@ float CanvasRenderingContext2D::shadowOffsetY() const void CanvasRenderingContext2D::setShadowOffsetY(float y) { + if (!isfinite(y)) + return; state().m_shadowOffset.setHeight(y); applyShadow(); } @@ -297,6 +301,8 @@ float CanvasRenderingContext2D::shadowBlur() const void CanvasRenderingContext2D::setShadowBlur(float blur) { + if (!(isfinite(blur) && blur >= 0)) + return; state().m_shadowBlur = blur; applyShadow(); } @@ -867,8 +873,6 @@ void CanvasRenderingContext2D::setShadow(float width, float height, float blur, return; RGBA32 rgba = makeRGBA32FromFloats(r, g, b, a); // default is transparent black - if (!state().m_shadowColor.isEmpty()) - CSSParser::parseColor(rgba, state().m_shadowColor); c->setShadow(IntSize(width, -height), state().m_shadowBlur, Color(rgba), DeviceColorSpace); } @@ -1274,14 +1278,30 @@ static PassRefPtr<ImageData> createEmptyImageData(const IntSize& size) return data.get(); } +PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(PassRefPtr<ImageData> imageData, ExceptionCode& ec) const +{ + if (!imageData) { + ec = NOT_SUPPORTED_ERR; + return 0; + } + + IntSize size(imageData->width(), imageData->height()); + return createEmptyImageData(size); +} + PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionCode& ec) const { ec = 0; + if (!sw || !sh) { + ec = INDEX_SIZE_ERR; + return 0; + } if (!isfinite(sw) || !isfinite(sh)) { ec = NOT_SUPPORTED_ERR; return 0; } - FloatSize unscaledSize(sw, sh); + + FloatSize unscaledSize(fabs(sw), fabs(sh)); IntSize scaledSize = canvas()->convertLogicalToDevice(unscaledSize); if (scaledSize.width() < 1) scaledSize.setWidth(1); @@ -1297,7 +1317,15 @@ PassRefPtr<ImageData> CanvasRenderingContext2D::getImageData(float sx, float sy, ec = SECURITY_ERR; return 0; } - + if (!sw || !sh) { + ec = INDEX_SIZE_ERR; + return 0; + } + if (!isfinite(sx) || !isfinite(sy) || !isfinite(sw) || !isfinite(sh)) { + ec = NOT_SUPPORTED_ERR; + return 0; + } + FloatRect unscaledRect(sx, sy, sw, sh); IntRect scaledRect = canvas()->convertLogicalToDevice(unscaledRect); if (scaledRect.width() < 1) @@ -1328,7 +1356,7 @@ void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, } if (!isfinite(dx) || !isfinite(dy) || !isfinite(dirtyX) || !isfinite(dirtyY) || !isfinite(dirtyWidth) || !isfinite(dirtyHeight)) { - ec = INDEX_SIZE_ERR; + ec = NOT_SUPPORTED_ERR; return; } diff --git a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h index 553ffd293b..2220f7e675 100644 --- a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h +++ b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h @@ -178,6 +178,7 @@ namespace WebCore { PassRefPtr<CanvasPattern> createPattern(HTMLImageElement*, const String& repetitionType, ExceptionCode&); PassRefPtr<CanvasPattern> createPattern(HTMLCanvasElement*, const String& repetitionType, ExceptionCode&); + PassRefPtr<ImageData> createImageData(PassRefPtr<ImageData> imageData, ExceptionCode&) const; PassRefPtr<ImageData> createImageData(float width, float height, ExceptionCode&) const; PassRefPtr<ImageData> getImageData(float sx, float sy, float sw, float sh, ExceptionCode&) const; void putImageData(ImageData*, float dx, float dy, ExceptionCode&); diff --git a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl index f93a7525a9..3f7ead714a 100644 --- a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl +++ b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl @@ -105,13 +105,12 @@ module html { [Custom] void drawImageFromRect(/* 10 */); [Custom] void setShadow(/* 3 */); [Custom] void createPattern(/* 2 */); + [Custom] ImageData createImageData(/* 3 */); attribute [Custom] custom strokeStyle; attribute [Custom] custom fillStyle; // pixel manipulation - ImageData createImageData(in float sw, in float sh) - raises (DOMException); ImageData getImageData(in float sx, in float sy, in float sw, in float sh) raises(DOMException); [Custom] void putImageData(/* in ImageData imagedata, in float dx, in float dy [, in float dirtyX, in float dirtyY, in float dirtyWidth, in float dirtyHeight] */); diff --git a/src/3rdparty/webkit/WebCore/page/AbstractView.idl b/src/3rdparty/webkit/WebCore/page/AbstractView.idl index 290bf4848a..e4ece0f575 100644 --- a/src/3rdparty/webkit/WebCore/page/AbstractView.idl +++ b/src/3rdparty/webkit/WebCore/page/AbstractView.idl @@ -32,7 +32,7 @@ module views { OmitConstructor ] AbstractView { readonly attribute Document document; - readonly attribute Media media; + readonly attribute Media styleMedia; }; } diff --git a/src/3rdparty/webkit/WebCore/page/ChromeClient.h b/src/3rdparty/webkit/WebCore/page/ChromeClient.h index 0bfdbaf78b..a01eef1cfd 100644 --- a/src/3rdparty/webkit/WebCore/page/ChromeClient.h +++ b/src/3rdparty/webkit/WebCore/page/ChromeClient.h @@ -222,7 +222,11 @@ namespace WebCore { virtual bool supportsFullscreenForNode(const Node*) { return false; } virtual void enterFullscreenForNode(Node*) { } virtual void exitFullscreenForNode(Node*) { } - + +#if ENABLE(TILED_BACKING_STORE) + virtual IntRect visibleRectForTiledBackingStore() const { return IntRect(); } +#endif + #if PLATFORM(MAC) virtual KeyboardUIMode keyboardUIMode() { return KeyboardAccessDefault; } diff --git a/src/3rdparty/webkit/WebCore/page/DOMWindow.cpp b/src/3rdparty/webkit/WebCore/page/DOMWindow.cpp index dd902005ef..8dcff5ca4f 100644 --- a/src/3rdparty/webkit/WebCore/page/DOMWindow.cpp +++ b/src/3rdparty/webkit/WebCore/page/DOMWindow.cpp @@ -57,7 +57,7 @@ #include "InspectorController.h" #include "InspectorTimelineAgent.h" #include "Location.h" -#include "Media.h" +#include "StyleMedia.h" #include "MessageEvent.h" #include "Navigator.h" #include "NotificationCenter.h" @@ -1112,10 +1112,10 @@ Document* DOMWindow::document() const return m_frame->document(); } -PassRefPtr<Media> DOMWindow::media() const +PassRefPtr<StyleMedia> DOMWindow::styleMedia() const { if (!m_media) - m_media = Media::create(m_frame); + m_media = StyleMedia::create(m_frame); return m_media.get(); } diff --git a/src/3rdparty/webkit/WebCore/page/DOMWindow.h b/src/3rdparty/webkit/WebCore/page/DOMWindow.h index a70713b201..cf9bc88d66 100644 --- a/src/3rdparty/webkit/WebCore/page/DOMWindow.h +++ b/src/3rdparty/webkit/WebCore/page/DOMWindow.h @@ -56,7 +56,7 @@ namespace WebCore { class IndexedDatabaseRequest; class InspectorTimelineAgent; class Location; - class Media; + class StyleMedia; class Navigator; class Node; class NotificationCenter; @@ -187,7 +187,7 @@ namespace WebCore { // DOM Level 2 AbstractView Interface Document* document() const; // CSSOM View Module - PassRefPtr<Media> media() const; + PassRefPtr<StyleMedia> styleMedia() const; // DOM Level 2 Style Interface PassRefPtr<CSSStyleDeclaration> getComputedStyle(Element*, const String& pseudoElt) const; @@ -353,7 +353,7 @@ namespace WebCore { Console* optionalConsole() const { return m_console.get(); } Navigator* optionalNavigator() const { return m_navigator.get(); } Location* optionalLocation() const { return m_location.get(); } - Media* optionalMedia() const { return m_media.get(); } + StyleMedia* optionalMedia() const { return m_media.get(); } #if ENABLE(DOM_STORAGE) Storage* optionalSessionStorage() const { return m_sessionStorage.get(); } Storage* optionalLocalStorage() const { return m_localStorage.get(); } @@ -390,7 +390,7 @@ namespace WebCore { mutable RefPtr<Console> m_console; mutable RefPtr<Navigator> m_navigator; mutable RefPtr<Location> m_location; - mutable RefPtr<Media> m_media; + mutable RefPtr<StyleMedia> m_media; #if ENABLE(DOM_STORAGE) mutable RefPtr<Storage> m_sessionStorage; mutable RefPtr<Storage> m_localStorage; diff --git a/src/3rdparty/webkit/WebCore/page/DOMWindow.idl b/src/3rdparty/webkit/WebCore/page/DOMWindow.idl index 31e4d4fee8..33e49e83f7 100644 --- a/src/3rdparty/webkit/WebCore/page/DOMWindow.idl +++ b/src/3rdparty/webkit/WebCore/page/DOMWindow.idl @@ -141,7 +141,7 @@ module window { readonly attribute Document document; // CSSOM View Module - readonly attribute Media media; + readonly attribute StyleMedia styleMedia; // DOM Level 2 Style Interface CSSStyleDeclaration getComputedStyle(in Element element, diff --git a/src/3rdparty/webkit/WebCore/page/EventHandler.cpp b/src/3rdparty/webkit/WebCore/page/EventHandler.cpp index 0a0e8c6458..c40299cf9a 100644 --- a/src/3rdparty/webkit/WebCore/page/EventHandler.cpp +++ b/src/3rdparty/webkit/WebCore/page/EventHandler.cpp @@ -230,6 +230,9 @@ void EventHandler::clear() m_capturingMouseEventsNode = 0; m_latchedWheelEventNode = 0; m_previousWheelScrolledNode = 0; +#if ENABLE(TOUCH_EVENTS) + m_originatingTouchPointTargets.clear(); +#endif } void EventHandler::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result) @@ -926,9 +929,13 @@ void EventHandler::setMousePressNode(PassRefPtr<Node> node) m_mousePressNode = node; } -bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity) +bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode) { - Node* node = m_frame->document()->focusedNode(); + Node* node = startingNode; + + if (!node) + node = m_frame->document()->focusedNode(); + if (!node) node = m_mousePressNode.get(); @@ -943,9 +950,9 @@ bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity g return false; } -bool EventHandler::scrollRecursively(ScrollDirection direction, ScrollGranularity granularity) +bool EventHandler::scrollRecursively(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode) { - bool handled = scrollOverflow(direction, granularity); + bool handled = scrollOverflow(direction, granularity, startingNode); if (!handled) { Frame* frame = m_frame; do { @@ -2714,21 +2721,21 @@ bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event) // Increment the platform touch id by 1 to avoid storing a key of 0 in the hashmap. unsigned touchPointTargetKey = point.id() + 1; - EventTarget* touchTarget = 0; + RefPtr<EventTarget> touchTarget; if (point.state() == PlatformTouchPoint::TouchPressed) { m_originatingTouchPointTargets.set(touchPointTargetKey, target); touchTarget = target; } else if (point.state() == PlatformTouchPoint::TouchReleased || point.state() == PlatformTouchPoint::TouchCancelled) { // The target should be the original target for this touch, so get it from the hashmap. As it's a release or cancel // we also remove it from the map. - touchTarget = m_originatingTouchPointTargets.take(touchPointTargetKey).get(); + touchTarget = m_originatingTouchPointTargets.take(touchPointTargetKey); } else - touchTarget = m_originatingTouchPointTargets.get(touchPointTargetKey).get(); + touchTarget = m_originatingTouchPointTargets.get(touchPointTargetKey); - if (!touchTarget) + if (!touchTarget.get()) continue; - RefPtr<Touch> touch = Touch::create(doc->frame(), touchTarget, point.id(), + RefPtr<Touch> touch = Touch::create(doc->frame(), touchTarget.get(), point.id(), point.screenPos().x(), point.screenPos().y(), adjustedPageX, adjustedPageY); diff --git a/src/3rdparty/webkit/WebCore/page/EventHandler.h b/src/3rdparty/webkit/WebCore/page/EventHandler.h index 282100d75b..a94e7bf3e6 100644 --- a/src/3rdparty/webkit/WebCore/page/EventHandler.h +++ b/src/3rdparty/webkit/WebCore/page/EventHandler.h @@ -130,9 +130,9 @@ public: static Frame* subframeForTargetNode(Node*); - bool scrollOverflow(ScrollDirection, ScrollGranularity); + bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = 0); - bool scrollRecursively(ScrollDirection, ScrollGranularity); + bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = 0); #if ENABLE(DRAG_SUPPORT) bool shouldDragAutoNode(Node*, const IntPoint&) const; // -webkit-user-drag == auto diff --git a/src/3rdparty/webkit/WebCore/page/FocusController.cpp b/src/3rdparty/webkit/WebCore/page/FocusController.cpp index 6c2a956fc6..a285e52dd1 100644 --- a/src/3rdparty/webkit/WebCore/page/FocusController.cpp +++ b/src/3rdparty/webkit/WebCore/page/FocusController.cpp @@ -319,7 +319,7 @@ bool FocusController::advanceFocusDirectionally(FocusDirection direction, Keyboa // if |node| element is not in the viewport. if (hasOffscreenRect(node)) { Frame* frame = node->document()->view()->frame(); - scrollInDirection(frame, direction); + scrollInDirection(frame, direction, focusCandidate); return true; } @@ -341,105 +341,152 @@ bool FocusController::advanceFocusDirectionally(FocusDirection direction, Keyboa return true; } -// FIXME: Make this method more modular, and simpler to understand and maintain. -static void updateFocusCandidateIfCloser(Node* focusedNode, const FocusCandidate& candidate, FocusCandidate& closest) +static void updateFocusCandidateInSameContainer(const FocusCandidate& candidate, FocusCandidate& closest) { - bool sameDocument = candidate.document() == closest.document(); - if (sameDocument) { - if (closest.alignment > candidate.alignment - || (closest.parentAlignment && candidate.alignment > closest.parentAlignment)) - return; - } else if (closest.alignment > candidate.alignment - && (closest.parentAlignment && candidate.alignment > closest.parentAlignment)) + if (closest.isNull()) { + closest = candidate; return; + } - if (candidate.alignment != None - || (closest.parentAlignment >= candidate.alignment - && closest.document() == candidate.document())) { + if (candidate.alignment == closest.alignment) { + if (candidate.distance < closest.distance) + closest = candidate; + return; + } - // If we are now in an higher precedent case, lets reset the current closest's - // distance so we force it to be bigger than any result we will get from - // spatialDistance(). - if (closest.alignment < candidate.alignment - && closest.parentAlignment < candidate.alignment) - closest.distance = maxDistance(); + if (candidate.alignment > closest.alignment) + closest = candidate; +} - closest.alignment = candidate.alignment; +static void updateFocusCandidateIfCloser(Node* focusedNode, const FocusCandidate& candidate, FocusCandidate& closest) +{ + // First, check the common case: neither candidate nor closest are + // inside scrollable content, then no need to care about enclosingScrollableBox + // heuristics or parent{Distance,Alignment}, but only distance and alignment. + if (!candidate.inScrollableContainer() && !closest.inScrollableContainer()) { + updateFocusCandidateInSameContainer(candidate, closest); + return; } - // Bail out if candidate's distance is larger than that of the closest candidate. - if (candidate.distance >= closest.distance) + bool sameContainer = candidate.document() == closest.document() && candidate.enclosingScrollableBox == closest.enclosingScrollableBox; + + // Second, if candidate and closest are in the same "container" (i.e. {i}frame or any + // scrollable block element), we can handle them as common case. + if (sameContainer) { + updateFocusCandidateInSameContainer(candidate, closest); return; + } - if (closest.isNull()) { + // Last, we are considering moving to a candidate located in a different enclosing + // scrollable box than closest. + bool isInInnerDocument = !isInRootDocument(focusedNode); + + bool sameContainerAsCandidate = isInInnerDocument ? focusedNode->document() == candidate.document() : + focusedNode->isDescendantOf(candidate.enclosingScrollableBox); + + bool sameContainerAsClosest = isInInnerDocument ? focusedNode->document() == closest.document() : + focusedNode->isDescendantOf(closest.enclosingScrollableBox); + + // sameContainerAsCandidate and sameContainerAsClosest are mutually exclusive. + ASSERT(!(sameContainerAsCandidate && sameContainerAsClosest)); + + if (sameContainerAsCandidate) { closest = candidate; return; } - // If the focused node and the candadate are in the same document and current - // closest candidate is not in an {i}frame that is preferable to get focused ... - if (focusedNode->document() == candidate.document() - && candidate.distance < closest.parentDistance) - closest = candidate; - else if (focusedNode->document() != candidate.document()) { - // If the focusedNode is in an inner document and candidate is in a - // different document, we only consider to change focus if there is not - // another already good focusable candidate in the same document as focusedNode. - if (!((isInRootDocument(candidate.node) && !isInRootDocument(focusedNode)) - && focusedNode->document() == closest.document())) + if (sameContainerAsClosest) { + // Nothing to be done. + return; + } + + // NOTE: !sameContainerAsCandidate && !sameContainerAsClosest + // If distance is shorter, and we are talking about scrollable container, + // lets compare parent distance and alignment before anything. + if (candidate.distance < closest.distance) { + if (candidate.alignment >= closest.parentAlignment + || candidate.parentAlignment == closest.parentAlignment) { closest = candidate; + return; + } + + } else if (candidate.parentDistance < closest.distance) { + if (candidate.parentAlignment >= closest.alignment) { + closest = candidate; + return; + } } } void FocusController::findFocusableNodeInDirection(Node* outer, Node* focusedNode, FocusDirection direction, KeyboardEvent* event, - FocusCandidate& closestFocusCandidate, - const FocusCandidate& candidateParent) + FocusCandidate& closest, const FocusCandidate& candidateParent) { ASSERT(outer); ASSERT(candidateParent.isNull() || candidateParent.node->hasTagName(frameTag) - || candidateParent.node->hasTagName(iframeTag)); + || candidateParent.node->hasTagName(iframeTag) + || isScrollableContainerNode(candidateParent.node)); + + // Walk all the child nodes and update closest if we find a nearer node. + Node* node = outer; + while (node) { - // Walk all the child nodes and update closestFocusCandidate if we find a nearer node. - Node* candidate = outer; - while (candidate) { // Inner documents case. + if (node->isFrameOwnerElement()) { + deepFindFocusableNodeInDirection(node, focusedNode, direction, event, closest); - if (candidate->isFrameOwnerElement()) - deepFindFocusableNodeInDirection(candidate, focusedNode, direction, event, closestFocusCandidate); - else if (candidate != focusedNode && candidate->isKeyboardFocusable(event)) { - FocusCandidate currentFocusCandidate(candidate); + // Scrollable block elements (e.g. <div>, etc) case. + } else if (isScrollableContainerNode(node)) { + deepFindFocusableNodeInDirection(node, focusedNode, direction, event, closest); + node = node->traverseNextSibling(); + continue; + + } else if (node != focusedNode && node->isKeyboardFocusable(event)) { + FocusCandidate candidate(node); + + // There are two ways to identify we are in a recursive call from deepFindFocusableNodeInDirection + // (i.e. processing an element in an iframe, frame or a scrollable block element): + + // 1) If candidateParent is not null, and it holds the distance and alignment data of the + // parent container element itself; + // 2) Parent of outer is <frame> or <iframe>; + // 3) Parent is any other scrollable block element. + if (!candidateParent.isNull()) { + candidate.parentAlignment = candidateParent.alignment; + candidate.parentDistance = candidateParent.distance; + candidate.enclosingScrollableBox = candidateParent.node; + + } else if (!isInRootDocument(outer)) { + if (Document* document = static_cast<Document*>(outer->parent())) + candidate.enclosingScrollableBox = static_cast<Node*>(document->ownerElement()); + + } else if (isScrollableContainerNode(outer->parent())) + candidate.enclosingScrollableBox = outer->parent(); // Get distance and alignment from current candidate. - distanceDataForNode(direction, focusedNode, currentFocusCandidate); + distanceDataForNode(direction, focusedNode, candidate); // Bail out if distance is maximum. - if (currentFocusCandidate.distance == maxDistance()) { - candidate = candidate->traverseNextNode(outer->parent()); + if (candidate.distance == maxDistance()) { + node = node->traverseNextNode(outer->parent()); continue; } - // If candidateParent is not null, it means that we are in a recursive call - // from deepFineFocusableNodeInDirection (i.e. processing an element in an iframe), - // and holds the distance and alignment data of the iframe element itself. - if (!candidateParent.isNull()) { - currentFocusCandidate.parentAlignment = candidateParent.alignment; - currentFocusCandidate.parentDistance = candidateParent.distance; - } - - updateFocusCandidateIfCloser(focusedNode, currentFocusCandidate, closestFocusCandidate); + updateFocusCandidateIfCloser(focusedNode, candidate, closest); } - candidate = candidate->traverseNextNode(outer->parent()); + node = node->traverseNextNode(outer->parent()); } } void FocusController::deepFindFocusableNodeInDirection(Node* container, Node* focusedNode, FocusDirection direction, KeyboardEvent* event, - FocusCandidate& closestFocusCandidate) + FocusCandidate& closest) { - ASSERT(container->hasTagName(frameTag) || container->hasTagName(iframeTag)); + ASSERT(container->hasTagName(frameTag) + || container->hasTagName(iframeTag) + || isScrollableContainerNode(container)); // Track if focusedNode is a descendant of the current container node being processed. bool descendantOfContainer = false; @@ -459,10 +506,15 @@ void FocusController::deepFindFocusableNodeInDirection(Node* container, Node* fo descendantOfContainer = innerDocument == focusedNode->document(); firstChild = innerDocument->firstChild(); + // Scrollable block elements (e.g. <div>, etc) + } else if (isScrollableContainerNode(container)) { + + firstChild = container->firstChild(); + descendantOfContainer = focusedNode->isDescendantOf(container); } if (descendantOfContainer) { - findFocusableNodeInDirection(firstChild, focusedNode, direction, event, closestFocusCandidate); + findFocusableNodeInDirection(firstChild, focusedNode, direction, event, closest); return; } @@ -476,8 +528,8 @@ void FocusController::deepFindFocusableNodeInDirection(Node* container, Node* fo return; // FIXME: Consider alignment? - if (candidateParent.distance < closestFocusCandidate.distance) - findFocusableNodeInDirection(firstChild, focusedNode, direction, event, closestFocusCandidate, candidateParent); + if (candidateParent.distance < closest.distance) + findFocusableNodeInDirection(firstChild, focusedNode, direction, event, closest, candidateParent); } static bool relinquishesEditingFocus(Node *node) diff --git a/src/3rdparty/webkit/WebCore/page/Frame.cpp b/src/3rdparty/webkit/WebCore/page/Frame.cpp index 6dbca69246..379bf7d816 100644 --- a/src/3rdparty/webkit/WebCore/page/Frame.cpp +++ b/src/3rdparty/webkit/WebCore/page/Frame.cpp @@ -37,6 +37,7 @@ #include "CSSPropertyNames.h" #include "CachedCSSStyleSheet.h" #include "Chrome.h" +#include "ChromeClient.h" #include "DOMWindow.h" #include "DocLoader.h" #include "DocumentType.h" @@ -1853,6 +1854,13 @@ IntRect Frame::tiledBackingStoreContentsRect() return IntRect(); return IntRect(IntPoint(), m_view->contentsSize()); } + +IntRect Frame::tiledBackingStoreVisibleRect() +{ + if (!m_page) + return IntRect(); + return m_page->chrome()->client()->visibleRectForTiledBackingStore(); +} #endif } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/page/Frame.h b/src/3rdparty/webkit/WebCore/page/Frame.h index 67761f9475..a654cd718f 100644 --- a/src/3rdparty/webkit/WebCore/page/Frame.h +++ b/src/3rdparty/webkit/WebCore/page/Frame.h @@ -288,6 +288,7 @@ namespace WebCore { virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&); virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea); virtual IntRect tiledBackingStoreContentsRect(); + virtual IntRect tiledBackingStoreVisibleRect(); #endif #if PLATFORM(MAC) diff --git a/src/3rdparty/webkit/WebCore/page/FrameView.cpp b/src/3rdparty/webkit/WebCore/page/FrameView.cpp index 39c92de43f..a53db367f8 100644 --- a/src/3rdparty/webkit/WebCore/page/FrameView.cpp +++ b/src/3rdparty/webkit/WebCore/page/FrameView.cpp @@ -80,23 +80,25 @@ using namespace HTMLNames; double FrameView::sCurrentPaintTimeStamp = 0.0; +// REPAINT_THROTTLING now chooses default values for throttling parameters. +// Should be removed when applications start using runtime configuration. #if ENABLE(REPAINT_THROTTLING) // Normal delay -static const double deferredRepaintDelay = 0.025; +double FrameView::s_deferredRepaintDelay = 0.025; // Negative value would mean that first few repaints happen without a delay -static const double initialDeferredRepaintDelayDuringLoading = 0; +double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0; // The delay grows on each repaint to this maximum value -static const double maxDeferredRepaintDelayDuringLoading = 2.5; +double FrameView::s_maxDeferredRepaintDelayDuringLoading = 2.5; // On each repaint the delay increses by this amount -static const double deferredRepaintDelayIncrementDuringLoading = 0.5; +double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0.5; #else // FIXME: Repaint throttling could be good to have on all platform. // The balance between CPU use and repaint frequency will need some tuning for desktop. // More hooks may be needed to reset the delay on things like GIF and CSS animations. -static const double deferredRepaintDelay = 0; -static const double initialDeferredRepaintDelayDuringLoading = 0; -static const double maxDeferredRepaintDelayDuringLoading = 0; -static const double deferredRepaintDelayIncrementDuringLoading = 0; +double FrameView::s_deferredRepaintDelay = 0; +double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0; +double FrameView::s_maxDeferredRepaintDelayDuringLoading = 0; +double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0; #endif // The maximum number of updateWidgets iterations that should be done before returning. @@ -200,7 +202,7 @@ void FrameView::reset() m_deferringRepaints = 0; m_repaintCount = 0; m_repaintRects.clear(); - m_deferredRepaintDelay = initialDeferredRepaintDelayDuringLoading; + m_deferredRepaintDelay = s_initialDeferredRepaintDelayDuringLoading; m_deferredRepaintTimer.stop(); m_lastPaintTime = 0; m_paintBehavior = PaintBehaviorNormal; @@ -1060,7 +1062,11 @@ void FrameView::setScrollPosition(const IntPoint& scrollPoint) void FrameView::scrollPositionChanged() { frame()->eventHandler()->sendScrollEvent(); + repaintFixedElementsAfterScrolling(); +} +void FrameView::repaintFixedElementsAfterScrolling() +{ // For fixed position elements, update widget positions and compositing layers after scrolling, // but only if we're not inside of layout. // FIXME: we could skip this if we knew the page had no fixed position elements. @@ -1214,13 +1220,13 @@ void FrameView::updateDeferredRepaintDelay() { Document* document = m_frame->document(); if (!document || (!document->parsing() && !document->docLoader()->requestCount())) { - m_deferredRepaintDelay = deferredRepaintDelay; + m_deferredRepaintDelay = s_deferredRepaintDelay; return; } - if (m_deferredRepaintDelay < maxDeferredRepaintDelayDuringLoading) { - m_deferredRepaintDelay += deferredRepaintDelayIncrementDuringLoading; - if (m_deferredRepaintDelay > maxDeferredRepaintDelayDuringLoading) - m_deferredRepaintDelay = maxDeferredRepaintDelayDuringLoading; + if (m_deferredRepaintDelay < s_maxDeferredRepaintDelayDuringLoading) { + m_deferredRepaintDelay += s_deferredRepaintDelayIncrementDuringLoading; + if (m_deferredRepaintDelay > s_maxDeferredRepaintDelayDuringLoading) + m_deferredRepaintDelay = s_maxDeferredRepaintDelayDuringLoading; } } @@ -2139,4 +2145,28 @@ IntPoint FrameView::convertFromContainingView(const IntPoint& parentPoint) const return parentPoint; } +// Normal delay +void FrameView::setRepaintThrottlingDeferredRepaintDelay(double p) +{ + s_deferredRepaintDelay = p; +} + +// Negative value would mean that first few repaints happen without a delay +void FrameView::setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p) +{ + s_initialDeferredRepaintDelayDuringLoading = p; +} + +// The delay grows on each repaint to this maximum value +void FrameView::setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p) +{ + s_maxDeferredRepaintDelayDuringLoading = p; +} + +// On each repaint the delay increases by this amount +void FrameView::setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p) +{ + s_deferredRepaintDelayIncrementDuringLoading = p; +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/page/FrameView.h b/src/3rdparty/webkit/WebCore/page/FrameView.h index 7371d13643..71fa8cd9ae 100644 --- a/src/3rdparty/webkit/WebCore/page/FrameView.h +++ b/src/3rdparty/webkit/WebCore/page/FrameView.h @@ -140,6 +140,7 @@ public: virtual void scrollRectIntoViewRecursively(const IntRect&); virtual void setScrollPosition(const IntPoint&); void scrollPositionChanged(); + virtual void repaintFixedElementsAfterScrolling(); String mediaType() const; void setMediaType(const String&); @@ -209,6 +210,15 @@ public: bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; } void invalidateScrollCorner(); + // Normal delay + static void setRepaintThrottlingDeferredRepaintDelay(double p); + // Negative value would mean that first few repaints happen without a delay + static void setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p); + // The delay grows on each repaint to this maximum value + static void setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p); + // On each repaint the delay increses by this amount + static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p); + protected: virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect); @@ -339,6 +349,11 @@ private: // Renderer to hold our custom scroll corner. RenderScrollbarPart* m_scrollCorner; + + static double s_deferredRepaintDelay; + static double s_initialDeferredRepaintDelayDuringLoading; + static double s_maxDeferredRepaintDelayDuringLoading; + static double s_deferredRepaintDelayIncrementDuringLoading; }; #if ENABLE(INSPECTOR) diff --git a/src/3rdparty/webkit/WebCore/page/SpatialNavigation.cpp b/src/3rdparty/webkit/WebCore/page/SpatialNavigation.cpp index 890eacd803..1ce61c32bb 100644 --- a/src/3rdparty/webkit/WebCore/page/SpatialNavigation.cpp +++ b/src/3rdparty/webkit/WebCore/page/SpatialNavigation.cpp @@ -124,8 +124,11 @@ static IntRect renderRectRelativeToRootDocument(RenderObject* render) // Handle nested frames. for (Frame* frame = render->document()->frame(); frame; frame = frame->tree()->parent()) { - if (HTMLFrameOwnerElement* ownerElement = frame->ownerElement()) - rect.move(ownerElement->offsetLeft(), ownerElement->offsetTop()); + if (Element* element = static_cast<Element*>(frame->ownerElement())) { + do { + rect.move(element->offsetLeft(), element->offsetTop()); + } while ((element = element->offsetParent())); + } } return rect; @@ -444,7 +447,7 @@ bool hasOffscreenRect(Node* node) // In a bottom-up way, this method tries to scroll |frame| in a given direction // |direction|, going up in the frame tree hierarchy in case it does not succeed. -bool scrollInDirection(Frame* frame, FocusDirection direction) +bool scrollInDirection(Frame* frame, FocusDirection direction, const FocusCandidate& candidate) { if (!frame) return false; @@ -468,6 +471,9 @@ bool scrollInDirection(Frame* frame, FocusDirection direction) return false; } + if (!candidate.isNull() && isScrollableContainerNode(candidate.enclosingScrollableBox)) + return frame->eventHandler()->scrollRecursively(scrollDirection, ScrollByLine, candidate.enclosingScrollableBox); + return frame->eventHandler()->scrollRecursively(scrollDirection, ScrollByLine); } @@ -477,9 +483,8 @@ void scrollIntoView(Element* element) // it is preferable to inflate |element|'s bounding rect a bit before // scrolling it for accurate reason. // Element's scrollIntoView method does not provide this flexibility. - static const int fudgeFactor = 2; IntRect bounds = element->getRect(); - bounds.inflate(fudgeFactor); + bounds.inflate(fudgeFactor()); element->renderer()->enclosingLayer()->scrollRectToVisible(bounds); } @@ -497,14 +502,14 @@ static void deflateIfOverlapped(IntRect& a, IntRect& b) if (!a.intersects(b) || a.contains(b) || b.contains(a)) return; - static const int fudgeFactor = -2; + int deflateFactor = -fudgeFactor(); // Avoid negative width or height values. - if ((a.width() + 2 * fudgeFactor > 0) && (a.height() + 2 * fudgeFactor > 0)) - a.inflate(fudgeFactor); + if ((a.width() + 2 * deflateFactor > 0) && (a.height() + 2 * deflateFactor > 0)) + a.inflate(deflateFactor); - if ((b.width() + 2 * fudgeFactor > 0) && (b.height() + 2 * fudgeFactor > 0)) - b.inflate(fudgeFactor); + if ((b.width() + 2 * deflateFactor > 0) && (b.height() + 2 * deflateFactor > 0)) + b.inflate(deflateFactor); } static bool checkNegativeCoordsForNode(Node* node, const IntRect& curRect) @@ -527,4 +532,17 @@ static bool checkNegativeCoordsForNode(Node* node, const IntRect& curRect) return canBeScrolled; } +bool isScrollableContainerNode(Node* node) +{ + if (!node) + return false; + + if (RenderObject* renderer = node->renderer()) { + return (renderer->isBox() && toRenderBox(renderer)->canBeScrolledAndHasScrollableArea() + && node->hasChildNodes() && !node->isDocumentNode()); + } + + return false; +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/page/SpatialNavigation.h b/src/3rdparty/webkit/WebCore/page/SpatialNavigation.h index 90ff1cf0e6..06389a3a58 100644 --- a/src/3rdparty/webkit/WebCore/page/SpatialNavigation.h +++ b/src/3rdparty/webkit/WebCore/page/SpatialNavigation.h @@ -40,6 +40,11 @@ inline long long maxDistance() return numeric_limits<long long>::max(); } +inline unsigned int fudgeFactor() +{ + return 2; +} + // Spatially speaking, two given elements in a web page can be: // 1) Fully aligned: There is a full intersection between the rects, either // vertically or horizontally. @@ -92,6 +97,7 @@ enum RectsAlignment { struct FocusCandidate { FocusCandidate() : node(0) + , enclosingScrollableBox(0) , distance(maxDistance()) , parentDistance(maxDistance()) , alignment(None) @@ -101,6 +107,7 @@ struct FocusCandidate { FocusCandidate(Node* n) : node(n) + , enclosingScrollableBox(0) , distance(maxDistance()) , parentDistance(maxDistance()) , alignment(None) @@ -109,9 +116,11 @@ struct FocusCandidate { } bool isNull() const { return !node; } + bool inScrollableContainer() const { return node && enclosingScrollableBox; } Document* document() const { return node ? node->document() : 0; } Node* node; + Node* enclosingScrollableBox; long long distance; long long parentDistance; RectsAlignment alignment; @@ -119,10 +128,11 @@ struct FocusCandidate { }; void distanceDataForNode(FocusDirection direction, Node* start, FocusCandidate& candidate); -bool scrollInDirection(Frame*, FocusDirection); +bool scrollInDirection(Frame*, FocusDirection, const FocusCandidate& candidate = FocusCandidate()); void scrollIntoView(Element*); bool hasOffscreenRect(Node*); bool isInRootDocument(Node*); +bool isScrollableContainerNode(Node*); } // namspace WebCore diff --git a/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp b/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp index 5c70effada..5753e1dc7d 100644 --- a/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp +++ b/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp @@ -292,6 +292,7 @@ void ScrollView::valueChanged(Scrollbar* scrollbar) if (scrollbarsSuppressed()) return; + repaintFixedElementsAfterScrolling(); scrollContents(scrollDelta); } diff --git a/src/3rdparty/webkit/WebCore/platform/ScrollView.h b/src/3rdparty/webkit/WebCore/platform/ScrollView.h index 9134ddfba5..0f79fa8622 100644 --- a/src/3rdparty/webkit/WebCore/platform/ScrollView.h +++ b/src/3rdparty/webkit/WebCore/platform/ScrollView.h @@ -302,6 +302,9 @@ private: // Called to update the scrollbars to accurately reflect the state of the view. void updateScrollbars(const IntSize& desiredOffset); + // Called when the scroll position within this view changes. FrameView overrides this to generate repaint invalidations. + virtual void repaintFixedElementsAfterScrolling() {} + void platformInit(); void platformDestroy(); void platformAddChild(Widget*); diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/BitmapImage.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/BitmapImage.cpp index 910d39a0ac..799055d616 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/BitmapImage.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/BitmapImage.cpp @@ -404,7 +404,9 @@ bool BitmapImage::internalAdvanceAnimation(bool skippingFrames) // Get the repetition count again. If we weren't able to get a // repetition count before, we should have decoded the whole image by // now, so it should now be available. - if (repetitionCount(true) && m_repetitionsComplete >= m_repetitionCount) { + // Note that we don't need to special-case cAnimationLoopOnce here + // because it is 0 (see comments on its declaration in ImageSource.h). + if (repetitionCount(true) != cAnimationLoopInfinite && m_repetitionsComplete > m_repetitionCount) { m_animationFinished = true; m_desiredFrameStartTime = 0; --m_currentFrame; diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/ImageSource.h b/src/3rdparty/webkit/WebCore/platform/graphics/ImageSource.h index 258fd0f695..0853d7beda 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/ImageSource.h +++ b/src/3rdparty/webkit/WebCore/platform/graphics/ImageSource.h @@ -86,7 +86,22 @@ typedef RefPtr<SharedBitmap> NativeImagePtr; #endif #endif -const int cAnimationLoopOnce = -1; +// Right now GIFs are the only recognized image format that supports animation. +// The animation system and the constants below are designed with this in mind. +// GIFs have an optional 16-bit unsigned loop count that describes how an +// animated GIF should be cycled. If the loop count is absent, the animation +// cycles once; if it is 0, the animation cycles infinitely; otherwise the +// animation plays n + 1 cycles (where n is the specified loop count). If the +// GIF decoder defaults to cAnimationLoopOnce in the absence of any loop count +// and translates an explicit "0" loop count to cAnimationLoopInfinite, then we +// get a couple of nice side effects: +// * By making cAnimationLoopOnce be 0, we allow the animation cycling code in +// BitmapImage.cpp to avoid special-casing it, and simply treat all +// non-negative loop counts identically. +// * By making the other two constants negative, we avoid conflicts with any +// real loop count values. +const int cAnimationLoopOnce = 0; +const int cAnimationLoopInfinite = -1; const int cAnimationNone = -2; class ImageSource : public Noncopyable { diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp index 6214f1bb9b..1d6f237068 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp @@ -35,6 +35,9 @@ TiledBackingStore::TiledBackingStore(TiledBackingStoreClient* client) , m_tileBufferUpdateTimer(new TileTimer(this, &TiledBackingStore::tileBufferUpdateTimerFired)) , m_tileCreationTimer(new TileTimer(this, &TiledBackingStore::tileCreationTimerFired)) , m_tileSize(defaultTileWidth, defaultTileHeight) + , m_tileCreationDelay(0.01) + , m_keepAreaMultiplier(2.f, 3.5f) + , m_coverAreaMultiplier(1.5f, 2.5f) , m_contentsScale(1.f) , m_pendingScale(0) , m_contentsFrozen(false) @@ -46,6 +49,25 @@ TiledBackingStore::~TiledBackingStore() delete m_tileBufferUpdateTimer; delete m_tileCreationTimer; } + +void TiledBackingStore::setTileSize(const IntSize& size) +{ + m_tileSize = size; + m_tiles.clear(); + startTileCreationTimer(); +} + +void TiledBackingStore::setTileCreationDelay(double delay) +{ + m_tileCreationDelay = delay; +} + +void TiledBackingStore::setKeepAndCoverAreaMultipliers(const FloatSize& keepMultiplier, const FloatSize& coverMultiplier) +{ + m_keepAreaMultiplier = keepMultiplier; + m_coverAreaMultiplier = coverMultiplier; + startTileCreationTimer(); +} void TiledBackingStore::invalidate(const IntRect& contentsDirtyRect) { @@ -120,22 +142,23 @@ void TiledBackingStore::paint(GraphicsContext* context, const IntRect& rect) if (currentTile && currentTile->isReadyToPaint()) currentTile->paint(context, dirtyRect); else { - FloatRect tileRect = tileRectForCoordinate(currentCoordinate); - FloatRect target = intersection(tileRect, FloatRect(rect)); - Tile::paintCheckerPattern(context, target); + IntRect tileRect = tileRectForCoordinate(currentCoordinate); + IntRect target = intersection(tileRect, dirtyRect); + if (target.isEmpty()) + continue; + Tile::paintCheckerPattern(context, FloatRect(target)); } } } context->restore(); } -void TiledBackingStore::viewportChanged(const IntRect& contentsViewport) +void TiledBackingStore::adjustVisibleRect() { - IntRect viewport = mapFromContents(contentsViewport); - if (m_viewport == viewport) + IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect()); + if (m_previousVisibleRect == visibleRect) return; - - m_viewport = viewport; + m_previousVisibleRect = visibleRect; startTileCreationTimer(); } @@ -177,24 +200,26 @@ void TiledBackingStore::createTiles() { if (m_contentsFrozen) return; + + IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect()); + m_previousVisibleRect = visibleRect; - if (m_viewport.isEmpty()) + if (visibleRect.isEmpty()) return; // Remove tiles that extend outside the current contents rect. dropOverhangingTiles(); - // FIXME: Make configurable/adapt to memory. - IntRect keepRect = m_viewport; - keepRect.inflateX(m_viewport.width()); - keepRect.inflateY(3 * m_viewport.height()); + IntRect keepRect = visibleRect; + keepRect.inflateX(visibleRect.width() * (m_keepAreaMultiplier.width() - 1.f)); + keepRect.inflateY(visibleRect.height() * (m_keepAreaMultiplier.height() - 1.f)); keepRect.intersect(contentsRect()); dropTilesOutsideRect(keepRect); - IntRect coverRect = m_viewport; - coverRect.inflateX(m_viewport.width() / 2); - coverRect.inflateY(2 * m_viewport.height()); + IntRect coverRect = visibleRect; + coverRect.inflateX(visibleRect.width() * (m_coverAreaMultiplier.width() - 1.f)); + coverRect.inflateY(visibleRect.height() * (m_coverAreaMultiplier.height() - 1.f)); coverRect.intersect(contentsRect()); // Search for the tile position closest to the viewport center that does not yet contain a tile. @@ -211,7 +236,7 @@ void TiledBackingStore::createTiles() continue; ++requiredTileCount; // Distance is 0 for all currently visible tiles. - double distance = tileDistance(m_viewport, currentCoordinate); + double distance = tileDistance(visibleRect, currentCoordinate); if (distance > shortestDistance) continue; if (distance < shortestDistance) { @@ -236,7 +261,7 @@ void TiledBackingStore::createTiles() // Keep creating tiles until the whole coverRect is covered. if (requiredTileCount) - m_tileCreationTimer->startOneShot(0); + m_tileCreationTimer->startOneShot(m_tileCreationDelay); } void TiledBackingStore::dropOverhangingTiles() diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h index 8ed4336e47..58477db9db 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h +++ b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h @@ -41,7 +41,7 @@ public: TiledBackingStore(TiledBackingStoreClient*); ~TiledBackingStore(); - void viewportChanged(const IntRect& viewportRect); + void adjustVisibleRect(); float contentsScale() { return m_contentsScale; } void setContentsScale(float); @@ -51,6 +51,20 @@ public: void invalidate(const IntRect& dirtyRect); void paint(GraphicsContext*, const IntRect&); + + IntSize tileSize() { return m_tileSize; } + void setTileSize(const IntSize&); + + double tileCreationDelay() const { return m_tileCreationDelay; } + void setTileCreationDelay(double delay); + + // Tiled are dropped outside the keep area, and created for cover area. The values a relative to the viewport size. + void getKeepAndCoverAreaMultipliers(FloatSize& keepMultiplier, FloatSize& coverMultiplier) + { + keepMultiplier = m_keepAreaMultiplier; + coverMultiplier = m_coverAreaMultiplier; + } + void setKeepAndCoverAreaMultipliers(const FloatSize& keepMultiplier, const FloatSize& coverMultiplier); private: void startTileBufferUpdateTimer(); @@ -94,8 +108,11 @@ private: TileTimer* m_tileCreationTimer; IntSize m_tileSize; + double m_tileCreationDelay; + FloatSize m_keepAreaMultiplier; + FloatSize m_coverAreaMultiplier; - IntRect m_viewport; + IntRect m_previousVisibleRect; float m_contentsScale; float m_pendingScale; diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h index 4adbbab501..c5845b9783 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h +++ b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h @@ -29,6 +29,7 @@ public: virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&) = 0; virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) = 0; virtual IntRect tiledBackingStoreContentsRect() = 0; + virtual IntRect tiledBackingStoreVisibleRect() = 0; }; #else diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp index 1e92dccced..ae1033e105 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp @@ -73,28 +73,31 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float QPainter *p = ctx->platformContext(); + QPen textFillPen; if (ctx->textDrawingMode() & cTextFill) { if (ctx->fillGradient()) { QBrush brush(*ctx->fillGradient()->platformGradient()); brush.setTransform(ctx->fillGradient()->gradientSpaceTransform()); - p->setPen(QPen(brush, 0)); + textFillPen = QPen(brush, 0); } else if (ctx->fillPattern()) { AffineTransform affine; - p->setPen(QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0)); + textFillPen = QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0); } else - p->setPen(QColor(ctx->fillColor())); + textFillPen = QPen(QColor(ctx->fillColor())); } + QPen textStrokePen; if (ctx->textDrawingMode() & cTextStroke) { if (ctx->strokeGradient()) { QBrush brush(*ctx->strokeGradient()->platformGradient()); brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform()); - p->setPen(QPen(brush, ctx->strokeThickness())); + textStrokePen = QPen(brush, ctx->strokeThickness()); } else if (ctx->strokePattern()) { AffineTransform affine; - p->setPen(QPen(QBrush(ctx->strokePattern()->createPlatformPattern(affine)), ctx->strokeThickness())); + QBrush brush(ctx->strokePattern()->createPlatformPattern(affine)); + textStrokePen = QPen(brush, ctx->strokeThickness()); } else - p->setPen(QPen(QColor(ctx->strokeColor()), ctx->strokeThickness())); + textStrokePen = QPen(QColor(ctx->strokeColor()), ctx->strokeThickness()); } String sanitized = Font::normalizeSpaces(String(run.characters(), run.length())); @@ -143,6 +146,7 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float line.draw(p, pt); p->restore(); } + p->setPen(textFillPen); line.draw(p, pt); p->restore(); return; @@ -163,10 +167,13 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float if (ctx->textDrawingMode() & cTextStroke) { QPainterPath path; path.addText(pt, font(), string); + p->setPen(textStrokePen); p->strokePath(path, p->pen()); } - if (ctx->textDrawingMode() & cTextFill) + if (ctx->textDrawingMode() & cTextFill) { + p->setPen(textFillPen); p->drawText(pt, string, flags, run.padding()); + } } float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>*) const diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp index edac268f85..bdb810a57e 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp @@ -167,8 +167,11 @@ static inline Qt::FillRule toQtFillRule(WindRule rule) } struct TransparencyLayer : FastAllocBase { - TransparencyLayer(const QPainter* p, const QRect &rect) + TransparencyLayer(const QPainter* p, const QRect &rect, qreal opacity, QPixmap& alphaMask) : pixmap(rect.width(), rect.height()) + , opacity(opacity) + , alphaMask(alphaMask) + , saveCounter(1) // see the comment for saveCounter { offset = rect.topLeft(); pixmap.fill(Qt::transparent); @@ -182,7 +185,9 @@ struct TransparencyLayer : FastAllocBase { painter.setFont(p->font()); if (painter.paintEngine()->hasFeature(QPaintEngine::PorterDuff)) painter.setCompositionMode(p->compositionMode()); - painter.setClipPath(p->clipPath()); + // if the path is an empty region, this assignment disables all painting + if (!p->clipPath().isEmpty()) + painter.setClipPath(p->clipPath()); } TransparencyLayer() @@ -193,6 +198,11 @@ struct TransparencyLayer : FastAllocBase { QPoint offset; QPainter painter; qreal opacity; + // for clipToImageBuffer + QPixmap alphaMask; + // saveCounter is only used in combination with alphaMask + // otherwise, its value is unspecified + int saveCounter; private: TransparencyLayer(const TransparencyLayer &) {} TransparencyLayer & operator=(const TransparencyLayer &) { return *this; } @@ -217,6 +227,9 @@ public: bool antiAliasingForRectsAndLines; QStack<TransparencyLayer*> layers; + // Counting real layers. Required by inTransparencyLayer() calls + // For example, layers with valid alphaMask are not real layers + int layerCount; QPainter* redirect; // reuse this brush for solid color (to prevent expensive QBrush construction) @@ -235,6 +248,7 @@ private: GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate(QPainter* p) { painter = p; + layerCount = 0; redirect = 0; solidColor = QBrush(Qt::black); @@ -289,11 +303,17 @@ AffineTransform GraphicsContext::getCTM() const void GraphicsContext::savePlatformState() { + if (!m_data->layers.isEmpty() && !m_data->layers.top()->alphaMask.isNull()) + ++m_data->layers.top()->saveCounter; m_data->p()->save(); } void GraphicsContext::restorePlatformState() { + if (!m_data->layers.isEmpty() && !m_data->layers.top()->alphaMask.isNull()) + if (!--m_data->layers.top()->saveCounter) + endTransparencyLayer(); + m_data->p()->restore(); if (!m_data->currentPath.isEmpty() && m_common->state.pathTransform.isInvertible()) { @@ -641,12 +661,12 @@ void GraphicsContext::fillRect(const FloatRect& rect) } } -void GraphicsContext::fillRect(const FloatRect& rect, const Color& c, ColorSpace colorSpace) +void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, ColorSpace colorSpace) { - if (paintingDisabled()) + if (paintingDisabled() || !color.isValid()) return; - m_data->solidColor.setColor(c); + m_data->solidColor.setColor(color); QPainter* p = m_data->p(); if (m_common->state.shadowColor.isValid()) drawBorderlessRectShadow(this, p, rect); @@ -655,7 +675,7 @@ void GraphicsContext::fillRect(const FloatRect& rect, const Color& c, ColorSpace void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color, ColorSpace colorSpace) { - if (paintingDisabled() || !color.alpha()) + if (paintingDisabled() || !color.isValid() || !color.alpha()) return; Path path = Path::createRoundedRectangle(rect, topLeft, topRight, bottomLeft, bottomRight); @@ -678,7 +698,7 @@ void GraphicsContext::addPath(const Path& path) bool GraphicsContext::inTransparencyLayer() const { - return !m_data->layers.isEmpty(); + return m_data->layerCount; } PlatformPath* GraphicsContext::currentPath() @@ -717,7 +737,7 @@ void GraphicsContext::drawFocusRing(const Vector<Path>& paths, int width, int of */ void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int /* width */, int /* offset */, const Color& color) { - if (paintingDisabled()) + if (paintingDisabled() || !color.isValid()) return; unsigned rectCount = rects.size(); @@ -837,10 +857,9 @@ void GraphicsContext::beginTransparencyLayer(float opacity) w = int(qBound(qreal(0), deviceClip.width(), (qreal)w) + 2); h = int(qBound(qreal(0), deviceClip.height(), (qreal)h) + 2); - TransparencyLayer * layer = new TransparencyLayer(m_data->p(), QRect(x, y, w, h)); - - layer->opacity = opacity; - m_data->layers.push(layer); + QPixmap emptyAlphaMask; + m_data->layers.push(new TransparencyLayer(m_data->p(), QRect(x, y, w, h), opacity, emptyAlphaMask)); + ++m_data->layerCount; } void GraphicsContext::endTransparencyLayer() @@ -849,6 +868,12 @@ void GraphicsContext::endTransparencyLayer() return; TransparencyLayer* layer = m_data->layers.pop(); + if (!layer->alphaMask.isNull()) { + layer->painter.resetTransform(); + layer->painter.setCompositionMode(QPainter::CompositionMode_DestinationIn); + layer->painter.drawPixmap(QPoint(), layer->alphaMask); + } else + --m_data->layerCount; // see the comment for layerCount layer->painter.end(); QPainter* p = m_data->p(); @@ -1086,9 +1111,21 @@ void GraphicsContext::clipOutEllipseInRect(const IntRect& rect) } } -void GraphicsContext::clipToImageBuffer(const FloatRect&, const ImageBuffer*) +void GraphicsContext::clipToImageBuffer(const FloatRect& floatRect, const ImageBuffer* image) { - notImplemented(); + if (paintingDisabled()) + return; + + QPixmap* nativeImage = image->image()->nativeImageForCurrentFrame(); + if (!nativeImage) + return; + + IntRect rect(floatRect); + QPixmap alphaMask = *nativeImage; + if (alphaMask.width() != rect.width() || alphaMask.height() != rect.height()) + alphaMask = alphaMask.scaled(rect.width(), rect.height()); + + m_data->layers.push(new TransparencyLayer(m_data->p(), m_data->p()->transform().mapRect(rect), 1.0, alphaMask)); } void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, @@ -1141,8 +1178,9 @@ void GraphicsContext::setURLForRect(const KURL&, const IntRect&) void GraphicsContext::setPlatformStrokeColor(const Color& color, ColorSpace colorSpace) { - if (paintingDisabled()) + if (paintingDisabled() || !color.isValid()) return; + QPainter* p = m_data->p(); QPen newPen(p->pen()); m_data->solidColor.setColor(color); @@ -1172,8 +1210,9 @@ void GraphicsContext::setPlatformStrokeThickness(float thickness) void GraphicsContext::setPlatformFillColor(const Color& color, ColorSpace colorSpace) { - if (paintingDisabled()) + if (paintingDisabled() || !color.isValid()) return; + m_data->solidColor.setColor(color); m_data->p()->setBrush(m_data->solidColor); } diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp index 1c4c275e08..ad2ec9c2d1 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp @@ -43,6 +43,7 @@ namespace WebCore { +#ifndef QT_NO_GRAPHICSEFFECT class MaskEffectQt : public QGraphicsEffect { public: MaskEffectQt(QObject* parent, QGraphicsItem* maskLayer) @@ -57,7 +58,12 @@ public: // It's more efficient to do it this way because // (a) we don't need the QBrush abstraction - we always end up using QGraphicsItem::paint from the mask layer // (b) QGraphicsOpacityEffect detaches the pixmap, which is inefficient on OpenGL. - QPixmap maskPixmap(sourceBoundingRect().toAlignedRect().size()); + const QSize maskSize = sourceBoundingRect().toAlignedRect().size(); + if (!maskSize.isValid() || maskSize.isEmpty()) { + drawSource(painter); + return; + } + QPixmap maskPixmap(maskSize); // we need to do this so the pixmap would have hasAlpha() maskPixmap.fill(Qt::transparent); @@ -91,6 +97,7 @@ public: QGraphicsItem* m_maskLayer; }; +#endif // QT_NO_GRAPHICSEFFECT class GraphicsLayerQtImpl : public QGraphicsObject { Q_OBJECT @@ -179,7 +186,9 @@ public: TransformationMatrix m_transformRelativeToRootLayer; bool m_transformAnimationRunning; bool m_opacityAnimationRunning; +#ifndef QT_NO_GRAPHICSEFFECT QWeakPointer<MaskEffectQt> m_maskEffect; +#endif struct ContentData { QPixmap pixmap; @@ -294,7 +303,7 @@ const GraphicsLayerQtImpl* GraphicsLayerQtImpl::rootLayer() const QPixmap GraphicsLayerQtImpl::recache(const QRegion& regionToUpdate) { - if (!m_layer->drawsContent()) + if (!m_layer->drawsContent() || m_size.isEmpty() ||!m_size.isValid()) return QPixmap(); QRegion region = regionToUpdate; @@ -321,6 +330,7 @@ QPixmap GraphicsLayerQtImpl::recache(const QRegion& regionToUpdate) // Render the actual contents into the cache painter.setCompositionMode(QPainter::CompositionMode_SourceOver); m_layer->paintGraphicsLayerContents(gc, region.boundingRect()); + painter.end(); m_backingStoreKey = QPixmapCache::insert(pixmap); return pixmap; @@ -357,14 +367,6 @@ void GraphicsLayerQtImpl::updateTransform() return; } - // Simplistic depth test - we stack the item behind its parent if its computed z is lower than the parent's computed z at the item's center point. - if (parent) { - const QPointF centerPointMappedToRoot = rootLayer()->mapFromItem(this, m_size.width() / 2, m_size.height() / 2); - setFlag(ItemStacksBehindParent, - m_transformRelativeToRootLayer.mapPoint(FloatPoint3D(centerPointMappedToRoot.x(), centerPointMappedToRoot.y(), 0)).z() < - parent->m_transformRelativeToRootLayer.mapPoint(FloatPoint3D(centerPointMappedToRoot.x(), centerPointMappedToRoot.y(), 0)).z()); - } - // The item is front-facing or backface-visibility is on. setVisible(true); @@ -523,6 +525,7 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive, bool forceUpdateTransform // we can't paint here, because we don't know if the mask layer // itself is ready... we'll have to wait till this layer tries to paint setFlag(ItemClipsChildrenToShape, m_layer->maskLayer() || m_layer->masksToBounds()); +#ifndef QT_NO_GRAPHICSEFFECT setGraphicsEffect(0); if (m_layer->maskLayer()) { if (GraphicsLayerQtImpl* mask = qobject_cast<GraphicsLayerQtImpl*>(m_layer->maskLayer()->platformLayer()->toGraphicsObject())) { @@ -530,6 +533,7 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive, bool forceUpdateTransform setGraphicsEffect(mask->m_maskEffect.data()); } } +#endif } if (m_changeMask & SizeChange) { @@ -604,11 +608,17 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive, bool forceUpdateTransform if ((m_changeMask & ContentsOpaqueChange) && m_state.contentsOpaque != m_layer->contentsOpaque()) prepareGeometryChange(); +#ifndef QT_NO_GRAPHICSEFFECT if (m_maskEffect) m_maskEffect.data()->update(); - else if (m_changeMask & DisplayChange) { + else +#endif + if (m_changeMask & DisplayChange) { // Recache now: all the content is ready and we don't want to wait until the paint event. - recache(m_pendingContent.regionToUpdate); + // We only need to do this for HTML content, there's no point in caching directly composited + // content like images or solid rectangles. + if (m_pendingContent.contentType == HTMLContentType) + recache(m_pendingContent.regionToUpdate); update(m_pendingContent.regionToUpdate.boundingRect()); m_pendingContent.regionToUpdate = QRegion(); } @@ -1197,9 +1207,9 @@ public: transformMatrix.blend(m_sourceMatrix, progress); } + m_layer.data()->m_layer->setTransform(transformMatrix); + // We force the actual opacity change, otherwise it would be ignored because of the animation. m_layer.data()->setBaseTransform(transformMatrix); - if (m_fillsForwards) - m_layer.data()->m_layer->setTransform(m_layer.data()->m_baseTransform); } virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) @@ -1237,18 +1247,19 @@ public: if (m_fillsForwards) setCurrentTime(1); } + virtual void applyFrame(const qreal& fromValue, const qreal& toValue, qreal progress) { qreal opacity = qBound(qreal(0), fromValue + (toValue-fromValue)*progress, qreal(1)); // FIXME: this is a hack, due to a probable QGraphicsScene bug. // Without this the opacity change doesn't always have immediate effect. - if (!m_layer.data()->opacity() && opacity) + if (m_layer.data()->scene() && !m_layer.data()->opacity() && opacity) m_layer.data()->scene()->update(); + m_layer.data()->m_layer->setOpacity(opacity); + // We force the actual opacity change, otherwise it would be ignored because of the animation. m_layer.data()->setOpacity(opacity); - if (m_fillsForwards) - m_layer.data()->m_layer->setOpacity(opacity); } virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp index d8315660a2..eafdcf04b4 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp @@ -46,12 +46,19 @@ namespace WebCore { ImageBufferData::ImageBufferData(const IntSize& size) : m_pixmap(size) + , m_painter(0) { + if (m_pixmap.isNull()) + return; + m_pixmap.fill(QColor(Qt::transparent)); - QPainter* painter = new QPainter(&m_pixmap); + QPainter* painter = new QPainter; m_painter.set(painter); + if (!painter->begin(&m_pixmap)) + return; + // Since ImageBuffer is used mainly for Canvas, explicitly initialize // its painter's pen and brush with the corresponding canvas defaults // NOTE: keep in sync with CanvasRenderingContext2D::State @@ -72,8 +79,11 @@ ImageBuffer::ImageBuffer(const IntSize& size, ImageColorSpace, bool& success) : m_data(size) , m_size(size) { + success = m_data.m_painter && m_data.m_painter->isActive(); + if (!success) + return; + m_context.set(new GraphicsContext(m_data.m_painter.get())); - success = true; } ImageBuffer::~ImageBuffer() diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageDecoderQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageDecoderQt.cpp index b10cc714f5..cc707da1b1 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageDecoderQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageDecoderQt.cpp @@ -115,22 +115,8 @@ size_t ImageDecoderQt::frameCount() int ImageDecoderQt::repetitionCount() const { - if (m_reader && m_reader->supportsAnimation()) { + if (m_reader && m_reader->supportsAnimation()) m_repetitionCount = m_reader->loopCount(); - - // Qt and WebCore have a incompatible understanding of - // the loop count and we can not completely map everything. - // Qt | WebCore | description - // -1 | 0 | infinite animation - // 0 | cAnimationLoopOnce | show every frame once - // n | n | no idea if that is supported - // n/a | cAnimationNone | show only the first frame - if (m_repetitionCount == -1) - m_repetitionCount = 0; - else if (m_repetitionCount == 0) - m_repetitionCount = cAnimationLoopOnce; - } - return m_repetitionCount; } @@ -205,6 +191,8 @@ bool ImageDecoderQt::internalHandleCurrentImage(size_t frameIndex) // Now get the QImage from Qt and place it in the RGBA32Buffer QImage img; if (!m_reader->read(&img)) { + frameCount(); + repetitionCount(); clearPointers(); return false; } diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp index ee4af7fe01..a7351a06e9 100644 --- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp @@ -69,12 +69,41 @@ Path& Path::operator=(const Path& other) return *this; } +// Check whether a point is on the border +bool isPointOnPathBorder(const QPolygonF& border, const QPointF& p) +{ + QPointF p1 = border.at(0); + QPointF p2; + + for (int i = 1; i < border.size(); ++i) { + p2 = border.at(i); + // (x1<=x<=x2||x1=>x>=x2) && (y1<=y<=y2||y1=>y>=y2) && (y2-y1)(x-x1) == (y-y1)(x2-x1) + // In which, (y2-y1)(x-x1) == (y-y1)(x2-x1) is from (y2-y1)/(x2-x1) == (y-y1)/(x-x1) + // it want to check the slope between p1 and p2 is same with slope between p and p1, + // if so then the three points lie on the same line. + // In which, (x1<=x<=x2||x1=>x>=x2) && (y1<=y<=y2||y1=>y>=y2) want to make sure p is + // between p1 and p2, not outside. + if (((p.x() <= p1.x() && p.x() >= p2.x()) || (p.x() >= p1.x() && p.x() <= p2.x())) + && ((p.y() <= p1.y() && p.y() >= p2.y()) || (p.y() >= p1.y() && p.y() <= p2.y())) + && (p2.y() - p1.y()) * (p.x() - p1.x()) == (p.y() - p1.y()) * (p2.x() - p1.x())) { + return true; + } + p1 = p2; + } + return false; +} + bool Path::contains(const FloatPoint& point, WindRule rule) const { Qt::FillRule savedRule = m_path.fillRule(); const_cast<QPainterPath*>(&m_path)->setFillRule(rule == RULE_EVENODD ? Qt::OddEvenFill : Qt::WindingFill); bool contains = m_path.contains(point); + + if (!contains) { + // check whether the point is on the border + contains = isPointOnPathBorder(m_path.toFillPolygon(), point); + } const_cast<QPainterPath*>(&m_path)->setFillRule(savedRule); return contains; @@ -269,9 +298,10 @@ void Path::addArc(const FloatPoint& p, float r, float sar, float ear, bool antic span += ea - sa; } - // connect to the previous point by a straight line - m_path.lineTo(QPointF(xc + radius * cos(sar), - yc - radius * sin(sar))); + // If the path is empty, move to where the arc will start to avoid painting a line from (0,0) + // NOTE: QPainterPath::isEmpty() won't work here since it ignores a lone MoveToElement + if (!m_path.elementCount()) + m_path.arcMoveTo(xs, ys, width, height, sa); m_path.arcTo(xs, ys, width, height, sa, span); diff --git a/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h b/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h index 781259cf1a..d1f2db4405 100644 --- a/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h +++ b/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h @@ -44,6 +44,15 @@ typedef const struct __SCDynamicStore * SCDynamicStoreRef; #include <windows.h> +#elif PLATFORM(QT) + +#include <QtCore/qglobal.h> + +#ifdef QT_NO_BEARERMANAGEMENT +#undef ENABLE_QT_BEARER +#define ENABLE_QT_BEARER 0 +#endif + #endif namespace WebCore { diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/DnsPrefetchHelper.h b/src/3rdparty/webkit/WebCore/platform/network/qt/DnsPrefetchHelper.h index 0d98fcb1ea..e3550251bb 100644 --- a/src/3rdparty/webkit/WebCore/platform/network/qt/DnsPrefetchHelper.h +++ b/src/3rdparty/webkit/WebCore/platform/network/qt/DnsPrefetchHelper.h @@ -42,6 +42,13 @@ namespace WebCore { if (currentLookups >= 10) return; // do not launch more than 10 lookups at the same time +#if QT_VERSION >= QT_VERSION_CHECK(4, 6, 3) + currentLookups++; + QHostInfo::lookupHost(hostname, this, SLOT(lookedUp(QHostInfo))); +#else + // This code is only needed for Qt versions that do not have + // the small Qt DNS cache yet. + QTime* entryTime = lookupCache.object(hostname); if (entryTime && entryTime->elapsed() > 300*1000) { // delete knowledge about lookup if it is already 300 seconds old @@ -54,6 +61,7 @@ namespace WebCore { currentLookups++; QHostInfo::lookupHost(hostname, this, SLOT(lookedUp(QHostInfo))); } +#endif } void lookedUp(const QHostInfo&) @@ -61,11 +69,14 @@ namespace WebCore { // we do not cache the result, we throw it away. // we currently rely on the OS to cache the results. If it does not do that // then at least the ISP nameserver did it. + // Since Qt 4.6.3, Qt also has a small DNS cache. currentLookups--; } protected: +#if QT_VERSION < QT_VERSION_CHECK(4, 6, 3) QCache<QString, QTime> lookupCache; // 100 entries +#endif int currentLookups; }; diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp b/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp index 52512aae2f..3aae92a255 100644 --- a/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp @@ -20,6 +20,8 @@ #include "config.h" #include "NetworkStateNotifier.h" +#if PLATFORM(QT) && ENABLE(QT_BEARER) + #include "NetworkStateNotifierPrivate.h" #include "qnetworkconfigmanager.h" @@ -89,4 +91,6 @@ void NetworkStateNotifier::setNetworkAccessAllowed(bool isAllowed) } // namespace WebCore +#endif + #include "moc_NetworkStateNotifierPrivate.cpp" diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp index 403718fa74..abeb895689 100644 --- a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp +++ b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp @@ -49,6 +49,7 @@ #define SIGNAL_CONN Qt::QueuedConnection #endif +static const int gMaxRecursionLimit = 10; namespace WebCore { @@ -139,6 +140,7 @@ QNetworkReplyHandler::QNetworkReplyHandler(ResourceHandle* handle, LoadMode load , m_shouldFinish(false) , m_shouldSendResponse(false) , m_shouldForwardData(false) + , m_redirectionTries(gMaxRecursionLimit) { const ResourceRequest &r = m_resourceHandle->request(); @@ -336,9 +338,18 @@ void QNetworkReplyHandler::sendResponseIfNeeded() QUrl redirection = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl(); if (redirection.isValid()) { + QUrl newUrl = m_reply->url().resolved(redirection); + + m_redirectionTries--; + if (m_redirectionTries == 0) { // 10 or more redirections to the same url is considered infinite recursion + ResourceError error(newUrl.host(), 400 /*bad request*/, + newUrl.toString(), + QCoreApplication::translate("QWebPage", "Redirection limit reached")); + client->didFail(m_resourceHandle, error); + return; + } m_redirected = true; - QUrl newUrl = m_reply->url().resolved(redirection); ResourceRequest newRequest = m_resourceHandle->request(); newRequest.setURL(newUrl); diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.h b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.h index eb5ae3c80a..1abad4e79c 100644 --- a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.h +++ b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.h @@ -82,6 +82,7 @@ private: bool m_shouldFinish; bool m_shouldSendResponse; bool m_shouldForwardData; + int m_redirectionTries; }; // Self destructing QIODevice for FormData diff --git a/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp index f9ced98538..54ecbf1696 100644 --- a/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp @@ -117,6 +117,7 @@ Vector<String> listDirectory(const String& path, const String& filter) CString openTemporaryFile(const char* prefix, PlatformFileHandle& handle) { +#ifndef QT_NO_TEMPORARYFILE QTemporaryFile* tempFile = new QTemporaryFile(QLatin1String(prefix)); tempFile->setAutoRemove(false); QFile* temp = tempFile; @@ -124,6 +125,7 @@ CString openTemporaryFile(const char* prefix, PlatformFileHandle& handle) handle = temp; return String(temp->fileName()).utf8(); } +#endif handle = invalidPlatformFileHandle; return CString(); } diff --git a/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h b/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h index 467941fe71..8e48d1f0f0 100644 --- a/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h +++ b/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h @@ -89,6 +89,8 @@ public: virtual QStyle* style() const = 0; + virtual QRectF graphicsItemVisibleRect() const { return QRectF(); } + protected: #ifndef QT_NO_CURSOR virtual QCursor cursor() const = 0; diff --git a/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp index 577903b8c9..08b7aca686 100644 --- a/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp @@ -163,7 +163,9 @@ RenderThemeQt::RenderThemeQt(Page* page) RenderThemeQt::~RenderThemeQt() { delete m_fallbackStyle; +#ifndef QT_NO_LINEEDIT delete m_lineEdit; +#endif } #if USE(QT_MOBILE_THEME) @@ -264,11 +266,17 @@ bool RenderThemeQt::supportsControlTints() const int RenderThemeQt::findFrameLineWidth(QStyle* style) const { +#ifndef QT_NO_LINEEDIT if (!m_lineEdit) m_lineEdit = new QLineEdit(); +#endif QStyleOptionFrameV2 opt; - return style->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, m_lineEdit); + QWidget* widget = 0; +#ifndef QT_NO_LINEEDIT + widget = m_lineEdit; +#endif + return style->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, widget); } static QRect inflateButtonRect(const QRect& originalRect, QStyle* style) diff --git a/src/3rdparty/webkit/WebCore/platform/qt/ScrollbarThemeQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/ScrollbarThemeQt.cpp index 04a2b1b0af..eb2d93489d 100644 --- a/src/3rdparty/webkit/WebCore/platform/qt/ScrollbarThemeQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/qt/ScrollbarThemeQt.cpp @@ -114,7 +114,7 @@ static QStyleOptionSlider* styleOptionSlider(Scrollbar* scrollbar, QWidget* widg opt.state |= QStyle::State_Horizontal; opt.sliderValue = scrollbar->value(); opt.sliderPosition = opt.sliderValue; - opt.pageStep = scrollbar->visibleSize(); + opt.pageStep = scrollbar->pageStep(); opt.singleStep = scrollbar->lineStep(); opt.minimum = 0; opt.maximum = qMax(0, scrollbar->maximum()); diff --git a/src/3rdparty/webkit/WebCore/platform/qt/TemporaryLinkStubs.cpp b/src/3rdparty/webkit/WebCore/platform/qt/TemporaryLinkStubsQt.cpp index 814f961516..814f961516 100644 --- a/src/3rdparty/webkit/WebCore/platform/qt/TemporaryLinkStubs.cpp +++ b/src/3rdparty/webkit/WebCore/platform/qt/TemporaryLinkStubsQt.cpp diff --git a/src/3rdparty/webkit/WebCore/platform/text/qt/TextBreakIteratorQt.cpp b/src/3rdparty/webkit/WebCore/platform/text/qt/TextBreakIteratorQt.cpp index 5a8a812bfc..dda443f20b 100644 --- a/src/3rdparty/webkit/WebCore/platform/text/qt/TextBreakIteratorQt.cpp +++ b/src/3rdparty/webkit/WebCore/platform/text/qt/TextBreakIteratorQt.cpp @@ -33,31 +33,49 @@ namespace WebCore { + static unsigned char buffer[1024]; + class TextBreakIterator : public QTextBoundaryFinder { + public: + TextBreakIterator(QTextBoundaryFinder::BoundaryType type, const UChar* string, int length) + : QTextBoundaryFinder(type, (const QChar*)string, length, buffer, sizeof(buffer)) + , length(length) + , string(string) {} + TextBreakIterator() + : QTextBoundaryFinder() + , length(0) + , string(0) {} + + int length; + const UChar* string; }; - static QTextBoundaryFinder* iterator = 0; - static unsigned char buffer[1024]; - TextBreakIterator* wordBreakIterator(const UChar* string, int length) + TextBreakIterator* setUpIterator(TextBreakIterator& iterator, QTextBoundaryFinder::BoundaryType type, const UChar* string, int length) { if (!string || !length) return 0; - if (!iterator) - iterator = new QTextBoundaryFinder; - *iterator = QTextBoundaryFinder(QTextBoundaryFinder::Word, (const QChar *)string, length, buffer, sizeof(buffer)); - return static_cast<TextBreakIterator*>(iterator); + if (iterator.isValid() && type == iterator.type() && length == iterator.length + && memcmp(string, iterator.string, length) == 0) { + iterator.toStart(); + return &iterator; + } + + iterator = TextBreakIterator(type, string, length); + + return &iterator; } - TextBreakIterator* characterBreakIterator(const UChar* string, int length) + TextBreakIterator* wordBreakIterator(const UChar* string, int length) { - if (!string || !length) - return 0; - if (!iterator) - iterator = new QTextBoundaryFinder; + static TextBreakIterator staticWordBreakIterator; + return setUpIterator(staticWordBreakIterator, QTextBoundaryFinder::Word, string, length); + } - *iterator = QTextBoundaryFinder(QTextBoundaryFinder::Grapheme, (const QChar *)string, length, buffer, sizeof(buffer)); - return static_cast<TextBreakIterator*>(iterator); + TextBreakIterator* characterBreakIterator(const UChar* string, int length) + { + static TextBreakIterator staticCharacterBreakIterator; + return setUpIterator(staticCharacterBreakIterator, QTextBoundaryFinder::Grapheme, string, length); } TextBreakIterator* cursorMovementIterator(const UChar* string, int length) @@ -67,25 +85,15 @@ namespace WebCore { TextBreakIterator* lineBreakIterator(const UChar* string, int length) { - static QTextBoundaryFinder *iterator = 0; - if (!string || !length) - return 0; - if (!iterator) - iterator = new QTextBoundaryFinder; - - *iterator = QTextBoundaryFinder(QTextBoundaryFinder::Line, (const QChar *)string, length, buffer, sizeof(buffer)); - return static_cast<TextBreakIterator*>(iterator); + static TextBreakIterator staticLineBreakIterator; + return setUpIterator(staticLineBreakIterator, QTextBoundaryFinder::Line, string, length); } TextBreakIterator* sentenceBreakIterator(const UChar* string, int length) { - if (!string || !length) - return 0; - if (!iterator) - iterator = new QTextBoundaryFinder; + static TextBreakIterator staticSentenceBreakIterator; + return setUpIterator(staticSentenceBreakIterator, QTextBoundaryFinder::Sentence, string, length); - *iterator = QTextBoundaryFinder(QTextBoundaryFinder::Sentence, (const QChar *)string, length, buffer, sizeof(buffer)); - return static_cast<TextBreakIterator*>(iterator); } int textBreakFirst(TextBreakIterator* bi) diff --git a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.mm index 1fd46767e3..57d74abcc1 100644 --- a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp +++ b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.mm @@ -103,9 +103,12 @@ static inline WindowRef nativeWindowFor(PlatformWidget widget) { #if PLATFORM(QT) if (widget) +#if QT_MAC_USE_COCOA + return static_cast<WindowRef>([qt_mac_window_for(widget) windowRef]); +#else return static_cast<WindowRef>(qt_mac_window_for(widget)); #endif -#if PLATFORM(WX) +#elif PLATFORM(WX) if (widget) return (WindowRef)widget->MacGetTopLevelWindowRef(); #endif diff --git a/src/3rdparty/webkit/WebCore/plugins/qt/PluginPackageQt.cpp b/src/3rdparty/webkit/WebCore/plugins/qt/PluginPackageQt.cpp index 74deaf62d1..d5292fe04c 100644 --- a/src/3rdparty/webkit/WebCore/plugins/qt/PluginPackageQt.cpp +++ b/src/3rdparty/webkit/WebCore/plugins/qt/PluginPackageQt.cpp @@ -35,6 +35,8 @@ namespace WebCore { +typedef void gtkInitFunc(int *argc, char ***argv); + bool PluginPackage::fetchInfo() { if (!load()) @@ -109,6 +111,7 @@ bool PluginPackage::load() NP_InitializeFuncPtr NP_Initialize; NPError npErr; + gtkInitFunc* gtkInit; NP_Initialize = (NP_InitializeFuncPtr)m_module->resolve("NP_Initialize"); m_NPP_Shutdown = (NPP_ShutdownProcPtr)m_module->resolve("NP_Shutdown"); @@ -127,6 +130,26 @@ bool PluginPackage::load() m_browserFuncs.getvalue = staticPluginQuirkRequiresGtkToolKit_NPN_GetValue; } + // WORKAROUND: Prevent gtk based plugin crashes such as BR# 40567 by + // explicitly forcing the initializing of Gtk, i.e. calling gtk_init, + // whenver the symbol is present in the plugin library loaded above. + // Note that this workaround is based on code from the NSPluginClass ctor + // in KDE's kdebase/apps/nsplugins/viewer/nsplugin.cpp file. + gtkInit = (gtkInitFunc*)m_module->resolve("gtk_init"); + if (gtkInit) { + // Prevent gtk_init() from replacing the X error handlers, since the Gtk + // handlers abort when they receive an X error, thus killing the viewer. +#ifdef Q_WS_X11 + int (*old_error_handler)(Display*, XErrorEvent*) = XSetErrorHandler(0); + int (*old_io_error_handler)(Display*) = XSetIOErrorHandler(0); +#endif + gtkInit(0, 0); +#ifdef Q_WS_X11 + XSetErrorHandler(old_error_handler); + XSetIOErrorHandler(old_io_error_handler); +#endif + } + #if defined(XP_UNIX) npErr = NP_Initialize(&m_browserFuncs, &m_pluginFuncs); #else |