diff options
Diffstat (limited to 'Source/WebKit')
318 files changed, 27671 insertions, 2680 deletions
diff --git a/Source/WebKit/CMakeLists.txt b/Source/WebKit/CMakeLists.txt index 3f3c80fb1..8bf565edc 100644 --- a/Source/WebKit/CMakeLists.txt +++ b/Source/WebKit/CMakeLists.txt @@ -22,6 +22,7 @@ SET(WebKit_INCLUDE_DIRECTORIES "${WEBCORE_DIR}/platform" "${WEBCORE_DIR}/platform/animation" "${WEBCORE_DIR}/platform/graphics" + "${WEBCORE_DIR}/platform/graphics/filters" "${WEBCORE_DIR}/platform/graphics/transforms" "${WEBCORE_DIR}/platform/network" "${WEBCORE_DIR}/platform/sql" @@ -44,6 +45,7 @@ SET(WebKit_INCLUDE_DIRECTORIES "${JAVASCRIPTCORE_DIR}/debugger" "${JAVASCRIPTCORE_DIR}/interpreter" "${JAVASCRIPTCORE_DIR}/jit" + "${JAVASCRIPTCORE_DIR}/llint" "${JAVASCRIPTCORE_DIR}/parser" "${JAVASCRIPTCORE_DIR}/profiler" "${JAVASCRIPTCORE_DIR}/runtime" @@ -65,7 +67,7 @@ SET(WebKit_LIBRARIES ${WebCore_LIBRARY_NAME} ) -INCLUDE_IF_EXISTS(${WEBKIT_DIR}/${WEBKIT_PORT_DIR}/CMakeLists${PORT}.txt) +WEBKIT_INCLUDE_CONFIG_FILES_IF_EXISTS() ADD_DEFINITIONS(-DBUILDING_WebKit) INCLUDE_DIRECTORIES(${WebKit_INCLUDE_DIRECTORIES}) diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog index 678b840f5..c95efcf3c 100644 --- a/Source/WebKit/ChangeLog +++ b/Source/WebKit/ChangeLog @@ -1,3 +1,465 @@ +2012-02-23 Patrick Gansterer <paroga@webkit.org> + + [CMake] Add WEBKIT_INCLUDE_CONFIG_FILES_IF_EXISTS macro + https://bugs.webkit.org/show_bug.cgi?id=79371 + + Reviewed by Daniel Bates. + + * CMakeLists.txt: + * PlatformBlackBerry.cmake: Renamed from Source/WebKit/blackberry/CMakeListsBlackBerry.txt. + * PlatformEfl.cmake: Renamed from Source/WebKit/efl/CMakeListsEfl.txt. + * PlatformWinCE.cmake: Renamed from Source/WebKit/wince/CMakeListsWinCE.txt. + +2012-02-20 Filip Pizlo <fpizlo@apple.com> + + JSC should be a triple-tier VM + https://bugs.webkit.org/show_bug.cgi?id=75812 + <rdar://problem/10079694> + + Reviewed by Gavin Barraclough. + + Changed EFL's build system to include a new directory in JavaScriptCore. + + * CMakeLists.txt: + +2012-02-21 Jon Lee <jonlee@apple.com> + + Bring notifications support to WK1 mac: showing, canceling, removing notifications + https://bugs.webkit.org/show_bug.cgi?id=78783 + <rdar://problem/10610578> + + Reviewed by Anders Carlsson. + + * WebKit.xcodeproj/project.pbxproj: Added new files. + +2012-02-21 Adam Roben <aroben@apple.com> + + Roll out r108309, r108323, and r108326 + + They broke the 32-bit Lion build. + + Original bugs is <http://webkit.org/b/75812> <rdar://problem/10079694>. + + * CMakeLists.txt: + +2012-02-16 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Adapt to the removal of WebStringIml.h + https://bugs.webkit.org/show_bug.cgi?id=78784 + + Reviewed by Antonio Gomes. + + blackberry/WebCoreSupport/WebStringImpl.h which hasn't been upstreamed + has been removed internally. We should adapt to this removal for the + upstreamed part of the BlackBerry port. Actually WebStringImpl is not necessary + because it just inherits from WTF::StringImpl but adding nothing. + + * blackberry/Api/WebString.cpp: + (BlackBerry::WebKit::WebString::WebString): + (BlackBerry::WebKit::WebString::equalIgnoringCase): + * blackberry/Api/WebString.h: + (WTF): + +2012-02-16 Nima Ghanavatian <nghanavatian@rim.com> + + [BlackBerry] Style clean-up in WebPageCompositor + https://bugs.webkit.org/show_bug.cgi?id=78738 + + Reviewed by Rob Buis. + + No new functionality, no new tests. + + * blackberry/WebKitSupport/WebPageCompositor.cpp: + (BlackBerry::WebKit::WebPageCompositor::drawLayers): + * blackberry/WebKitSupport/WebPageCompositor.h: + (WebKit): + +2012-02-16 Patrick Gansterer <paroga@webkit.org> + + [CMake] Add missing include directories. + + * CMakeLists.txt: + +2012-02-15 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Remove ResourceHolderImpl.cpp from build system + https://bugs.webkit.org/show_bug.cgi?id=78779 + + Reviewed by George Staikos. + + blackberry/Api/ResourceHolderImpl.cpp which hasn't been upstreamed + has been removed internally. So remove it from the build system. + + * blackberry/CMakeListsBlackBerry.txt: + +2012-02-15 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Upstream WebPageGroupLoadDeferrer.{h, cpp} + https://bugs.webkit.org/show_bug.cgi?id=78770 + + Reviewed by Rob Buis. + + Initial upstreaming, no new tests. + + * blackberry/Api/WebPageGroupLoadDeferrer.cpp: Added. + * blackberry/Api/WebPageGroupLoadDeferrer.h: Added. + +2012-02-15 Konrad Piascik <kpiascik@rim.com> + + [BlackBerry] Upstream BlackBerry specific Web Inspector resources + https://bugs.webkit.org/show_bug.cgi?id=78727 + + Reviewed by Rob Buis. + + * blackberry/WebCoreSupport/inspectorBB.html: Added. + * blackberry/WebCoreSupport/inspectorBB.js: Added. + (): + (InspectorFrontendHost.copyText): + +2012-02-15 Mike Fenton <mifenton@rim.com> + + Initial upstreaming of EditorClientBlackBerry + https://bugs.webkit.org/show_bug.cgi?id=78730 + + Reviewed by Rob Buis. + + Initial upstreaming, no new tests. + + * blackberry/WebCoreSupport/EditorClientBlackBerry.cpp: Added. + (WebCore): + (WebCore::EditorClientBlackBerry::EditorClientBlackBerry): + (WebCore::EditorClientBlackBerry::pageDestroyed): + (WebCore::EditorClientBlackBerry::shouldDeleteRange): + (WebCore::EditorClientBlackBerry::shouldShowDeleteInterface): + (WebCore::EditorClientBlackBerry::smartInsertDeleteEnabled): + (WebCore::EditorClientBlackBerry::isSelectTrailingWhitespaceEnabled): + (WebCore::EditorClientBlackBerry::enableSpellChecking): + (WebCore::EditorClientBlackBerry::shouldSpellCheckFocusedField): + (WebCore::EditorClientBlackBerry::isContinuousSpellCheckingEnabled): + (WebCore::EditorClientBlackBerry::toggleContinuousSpellChecking): + (WebCore::EditorClientBlackBerry::isGrammarCheckingEnabled): + (WebCore::EditorClientBlackBerry::toggleGrammarChecking): + (WebCore::EditorClientBlackBerry::spellCheckerDocumentTag): + (WebCore::EditorClientBlackBerry::shouldBeginEditing): + (WebCore::EditorClientBlackBerry::shouldEndEditing): + (WebCore::EditorClientBlackBerry::shouldInsertNode): + (WebCore::EditorClientBlackBerry::shouldInsertText): + (WebCore::EditorClientBlackBerry::shouldChangeSelectedRange): + (WebCore::EditorClientBlackBerry::shouldApplyStyle): + (WebCore::EditorClientBlackBerry::shouldMoveRangeAfterDelete): + (WebCore::EditorClientBlackBerry::didBeginEditing): + (WebCore::EditorClientBlackBerry::respondToChangedContents): + (WebCore::EditorClientBlackBerry::respondToChangedSelection): + (WebCore::EditorClientBlackBerry::didEndEditing): + (WebCore::EditorClientBlackBerry::respondToSelectionAppearanceChange): + (WebCore::EditorClientBlackBerry::didWriteSelectionToPasteboard): + (WebCore::EditorClientBlackBerry::didSetSelectionTypesForPasteboard): + (WebCore::EditorClientBlackBerry::registerCommandForUndo): + (WebCore::EditorClientBlackBerry::registerCommandForRedo): + (WebCore::EditorClientBlackBerry::clearUndoRedoOperations): + (WebCore::EditorClientBlackBerry::canUndo): + (WebCore::EditorClientBlackBerry::canRedo): + (WebCore::EditorClientBlackBerry::canCopyCut): + (WebCore::EditorClientBlackBerry::canPaste): + (WebCore::EditorClientBlackBerry::undo): + (WebCore::EditorClientBlackBerry::redo): + (KeyDownEntry): + (KeyPressEntry): + (WebCore::EditorClientBlackBerry::interpretKeyEvent): + (WebCore::EditorClientBlackBerry::handleKeyboardEvent): + (WebCore::EditorClientBlackBerry::handleInputMethodKeydown): + (WebCore::EditorClientBlackBerry::textFieldDidBeginEditing): + (WebCore::EditorClientBlackBerry::textFieldDidEndEditing): + (WebCore::EditorClientBlackBerry::textDidChangeInTextField): + (WebCore::EditorClientBlackBerry::doTextFieldCommandFromEvent): + (WebCore::EditorClientBlackBerry::textWillBeDeletedInTextField): + (WebCore::EditorClientBlackBerry::textDidChangeInTextArea): + (WebCore::EditorClientBlackBerry::ignoreWordInSpellDocument): + (WebCore::EditorClientBlackBerry::learnWord): + (WebCore::EditorClientBlackBerry::checkSpellingOfString): + (WebCore::EditorClientBlackBerry::getAutoCorrectSuggestionForMisspelledWord): + (WebCore::EditorClientBlackBerry::checkGrammarOfString): + (WebCore::EditorClientBlackBerry::requestCheckingOfString): + (WebCore::EditorClientBlackBerry::textChecker): + (WebCore::EditorClientBlackBerry::updateSpellingUIWithGrammarString): + (WebCore::EditorClientBlackBerry::updateSpellingUIWithMisspelledWord): + (WebCore::EditorClientBlackBerry::showSpellingUI): + (WebCore::EditorClientBlackBerry::spellingUIIsShowing): + (WebCore::EditorClientBlackBerry::getGuessesForWord): + (WebCore::EditorClientBlackBerry::willSetInputMethodState): + (WebCore::EditorClientBlackBerry::setInputMethodState): + * blackberry/WebCoreSupport/EditorClientBlackBerry.h: Added. + (WebKit): + (WebCore): + (EditorClientBlackBerry): + +2012-02-15 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Upstream WebPageClient.h + https://bugs.webkit.org/show_bug.cgi?id=78660 + + Reviewed by Antonio Gomes. + + Initial upstreaming, no new tests. + + * blackberry/Api/BackingStore.cpp: Add #include <BlackBerryPlatformWindow.h> because this inclusion + is being removed from WebPageClient.h. + * blackberry/Api/WebPageClient.h: Added. + * blackberry/WebCoreSupport/ChromeClientBlackBerry.cpp: Add #include <BlackBerryPlatformWindow.h> + because this inclusion is being removed from WebPageClient.h. + +2012-02-15 Rob Buis <rbuis@rim.com> + + [BlackBerry] Upstream remaining classes in Api + https://bugs.webkit.org/show_bug.cgi?id=78644 + + Reviewed by Antonio Gomes. + + No functionalities changed, no new tests. + + * blackberry/Api/ActiveNodeContext.h: Renamed from Source/WebKit/blackberry/Api/BlackBerryContext.h. + +2012-02-14 Nima Ghanavatian <nghanavatian@rim.com> + + [BlackBerry] Upstreaming WebSettings code + https://bugs.webkit.org/show_bug.cgi?id=78633 + + Reviewed by Rob Buis. + + Initial upstreaming, no new tests. + + * blackberry/Api/WebSettings.cpp: Added. + * blackberry/Api/WebSettings.h: Added. + * blackberry/Api/WebSettings_p.h: Added. + +2012-02-14 Nima Ghanavatian <nghanavatian@rim.com> + + [BlackBerry] Upstreaming DOMSupport files + https://bugs.webkit.org/show_bug.cgi?id=78607 + + Reviewed by Rob Buis. + + Initial upstreaming, no new tests. + + * blackberry/WebKitSupport/DOMSupport.cpp: Added. + * blackberry/WebKitSupport/DOMSupport.h: Added. + +2012-02-14 Jeff Rogers <jrogers@rim.com> + + [BlackBerry] Remove OpenVG references + https://bugs.webkit.org/show_bug.cgi?id=78623 + + Reviewed by Rob Buis. + + Removed references to USE(OPENVG) and the related code. + + * blackberry/Api/BackingStore.cpp: + (BlackBerry::WebKit::BackingStorePrivate::BackingStorePrivate): + (BlackBerry::WebKit::BackingStorePrivate::repaint): + (BlackBerry::WebKit::BackingStorePrivate::renderContents): + (BlackBerry::WebKit::BackingStore::createSurface): + * blackberry/Api/BackingStore_p.h: + +2012-02-14 Andy Chen <andchen@rim.com> + + Initial upstreaming for find-in-page for BlackBerry port + https://bugs.webkit.org/show_bug.cgi?id=78615 + + Create a new class InPageSearchManager for find-in-page and + remove the functions in SelectionHandler + + Reviewed by Rob Buis. + + * blackberry/CMakeListsBlackBerry.txt: + * blackberry/WebKitSupport/InPageSearchManager.cpp: Added. + (BlackBerry::WebKit::InPageSearchManager::InPageSearchManager): + (BlackBerry::WebKit::InPageSearchManager::~InPageSearchManager): + (BlackBerry::WebKit::InPageSearchManager::findNextString): + (BlackBerry::WebKit::InPageSearchManager::clearTextMatches): + (BlackBerry::WebKit::InPageSearchManager::setMarkerActive): + * blackberry/WebKitSupport/InPageSearchManager.h: Added. + * blackberry/WebKitSupport/SelectionHandler.cpp: + * blackberry/WebKitSupport/SelectionHandler.h: + +2012-02-14 Jacky Jiang <zhajiang@rim.com> + + [BlackBerry] Upstream BlackBerry WebCoreSupport FrameLoaderClientBlackBerry class + https://bugs.webkit.org/show_bug.cgi?id=78275 + + Reviewed by Rob Buis. + + Initial upstream, no new tests. + + * blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.cpp: Added. + * blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.h: Added. + +2012-02-14 Lianghui Chen <liachen@rim.com> + + Separate mimetype and file extension mapping API from WebKit/blackberry/Api/WebKitTextCodec and complete it. + https://bugs.webkit.org/show_bug.cgi?id=78605 + + Reviewed by Rob Buis. + + Now the MIME type and file extension mapping API are in WebKitMIMETypeConverter. + + * blackberry/Api/WebKitMIMETypeConverter.cpp: Added. + (WebKit): + (BlackBerry::WebKit::getExtensionForMimeType): + (BlackBerry::WebKit::getMimeTypeForExtension): + * blackberry/Api/WebKitMIMETypeConverter.h: Added. + (WebKit): + * blackberry/Api/WebKitTextCodec.cpp: + * blackberry/Api/WebKitTextCodec.h: + * blackberry/CMakeListsBlackBerry.txt: + +2012-02-14 Ed Baker <edbaker@rim.com> + + [BlackBerry] Dragging a selection handle outside of the content bounding box does not update the selection range correctly + https://bugs.webkit.org/show_bug.cgi?id=78608 + + Ensure that when selection handles leave the content bounding box that + the handle not being dragged remains fixed. Do not applying padding to + a direction that would cause the selection to shrink when performing + the handle direction detection. + + Reviewed by Rob Buis. + + * blackberry/WebKitSupport/SelectionHandler.cpp: + (BlackBerry::WebKit::directionOfPointRelativeToRect): + (BlackBerry::WebKit::SelectionHandler::extendSelectionToFieldBoundary): + (BlackBerry::WebKit::SelectionHandler::clipPointToFocusNode): + (BlackBerry::WebKit::SelectionHandler::setSelection): + * blackberry/WebKitSupport/SelectionHandler.h: + +2012-02-14 Rob Buis <rbuis@rim.com> + + [BlackBerry] Upstream remaining classes in Api + https://bugs.webkit.org/show_bug.cgi?id=78644 + + Reviewed by Antonio Gomes. + + Initial upstream, no new tests. + + * blackberry/Api/BlackBerryContext.h: Added. + * blackberry/Api/BlackBerryGlobal.cpp: Added. + * blackberry/Api/BlackBerryGlobal.h: Added. + * blackberry/Api/Version.cpp: Added. + * blackberry/Api/Version.h: Added. + +2012-02-14 Rob Buis <rbuis@rim.com> + + [BlackBerry] Upstream backing store related classes + https://bugs.webkit.org/show_bug.cgi?id=78517 + + Reviewed by Antonio Gomes. + + Initial upstream, no new tests. + + * blackberry/WebKitSupport/BackingStoreClient.cpp: Added. + * blackberry/WebKitSupport/BackingStoreClient.h: Added. + * blackberry/WebKitSupport/BackingStoreCompositingSurface.cpp: Added. + * blackberry/WebKitSupport/BackingStoreCompositingSurface.h: Added. + * blackberry/WebKitSupport/BackingStoreTile.cpp: Added. + * blackberry/WebKitSupport/BackingStoreTile.h: Added. + +2012-02-13 Nima Ghanavatian <nghanavatian@rim.com> + + Initial upstreaming of selection handling code for BlackBerry port + https://bugs.webkit.org/show_bug.cgi?id=78136 + + Reviewed by Rob Buis. + + Initial upstreaming, no new tests. + + * blackberry/WebKitSupport/SelectionHandler.cpp: Added. + * blackberry/WebKitSupport/SelectionHandler.h: Added. + +2012-02-10 Mike Fenton <mifenton@rim.com> + + BlackBerry Port - Input focus is suppressed during XHR loads + https://bugs.webkit.org/show_bug.cgi?id=78368 + + Allow JS to trigger the VKB and input focus when XHR scripting + is active. + + This switching the loaded state to checking the webpages loaded state + which is only updated after initial load. When additional loading + events happen for XHR, it remains false and focus events function. + + Also add detailed FocusLog's to shouldAcceptInputFocus. + + Reviewed by Rob Buis. + + * blackberry/WebKitSupport/InputHandler.cpp: + (BlackBerry::WebKit::InputHandler::shouldAcceptInputFocus): + +2012-02-10 Mike Fenton <mifenton@rim.com> + + BlackBerry Port - JS focus on blur can cause recursion + https://bugs.webkit.org/show_bug.cgi?id=78368 + + Prevent JS recursion of blur/focus by allowing focus + if we are already trying to prevent focus. + + Reviewed by Rob Buis. + + * blackberry/WebKitSupport/InputHandler.cpp: + (BlackBerry::WebKit::InputHandler::InputHandler): + (BlackBerry::WebKit::InputHandler::shouldAcceptInputFocus): + (BlackBerry::WebKit::InputHandler::setElementFocused): + * blackberry/WebKitSupport/InputHandler.h: + (InputHandler): + +2012-02-10 Rob Buis <rbuis@rim.com> + + [BlackBerry] Upstream graphics helper classes in WebKitSupport + https://bugs.webkit.org/show_bug.cgi?id=78278 + + Reviewed by Antonio Gomes. + + Initial upstream, no new tests. + + * blackberry/WebKitSupport/RenderQueue.cpp: Added. + * blackberry/WebKitSupport/RenderQueue.h: Added. + +2012-02-10 Rob Buis <rbuis@rim.com> + + [BlackBerry] Upstream graphics helper classes in WebKitSupport + https://bugs.webkit.org/show_bug.cgi?id=78278 + + Reviewed by Antonio Gomes. + + Initial upstream, no new tests. + + * blackberry/WebKitSupport/SurfacePool.cpp: Added. + * blackberry/WebKitSupport/SurfacePool.h: Added. + * blackberry/WebKitSupport/TileIndex.h: Added. + * blackberry/WebKitSupport/TileIndexHash.h: Added. + +2012-02-09 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Upstream JavaScriptDebuggerBlackBerry.{h, cpp} + https://bugs.webkit.org/show_bug.cgi?id=78203 + + Reviewed by Rob Buis. + + Initial upstream, no new tests. + + * blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.cpp: Added. + * blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.h: Added. + +2012-02-09 Rob Buis <rbuis@rim.com> + + [BlackBerry] Upstream BlackBerry WebKitSupport WebPageCompositor class + https://bugs.webkit.org/show_bug.cgi?id=78276 + + Reviewed by Antonio Gomes. + + Initial upstream, no new tests. + + * blackberry/WebKitSupport/WebPageCompositor.cpp: Added. + * blackberry/WebKitSupport/WebPageCompositor.h: Added. + 2012-02-08 Jacky Jiang <zhajiang@rim.com> [BlackBerry] Upstream BlackBerry WebCoreSupport FrameNetworkingContextBlackBerry and IconDatabaseClientBlackBerry classes diff --git a/Source/WebKit/blackberry/CMakeListsBlackBerry.txt b/Source/WebKit/PlatformBlackBerry.cmake index d0e27cfd6..5d5c8b352 100644 --- a/Source/WebKit/blackberry/CMakeListsBlackBerry.txt +++ b/Source/WebKit/PlatformBlackBerry.cmake @@ -41,7 +41,7 @@ LIST(APPEND WebKit_SOURCES blackberry/Api/BackingStore.cpp blackberry/Api/BlackBerryGlobal.cpp blackberry/Api/WebString.cpp - blackberry/Api/ResourceHolderImpl.cpp + blackberry/Api/WebKitMIMETypeConverter.cpp blackberry/Api/WebKitTextCodec.cpp blackberry/Api/WebPage.cpp blackberry/Api/WebPageGroupLoadDeferrer.cpp @@ -67,6 +67,7 @@ LIST(APPEND WebKit_SOURCES blackberry/WebKitSupport/BackingStoreClient.cpp blackberry/WebKitSupport/DOMSupport.cpp blackberry/WebKitSupport/FrameLayers.cpp + blackberry/WebKitSupport/InPageSearchManager.cpp blackberry/WebKitSupport/InputHandler.cpp blackberry/WebKitSupport/OutOfMemoryHandler.cpp blackberry/WebKitSupport/RenderQueue.cpp diff --git a/Source/WebKit/efl/CMakeListsEfl.txt b/Source/WebKit/PlatformEfl.cmake index ec0c7d894..daf22876e 100644 --- a/Source/WebKit/efl/CMakeListsEfl.txt +++ b/Source/WebKit/PlatformEfl.cmake @@ -1,5 +1,3 @@ -INCLUDE(WebKitEfl) - LIST(APPEND WebKit_LINK_FLAGS ${ECORE_X_LDFLAGS} ${EDJE_LDFLAGS} @@ -10,6 +8,7 @@ LIST(APPEND WebKit_LINK_FLAGS LIST(APPEND WebKit_INCLUDE_DIRECTORIES "${WEBKIT_DIR}/efl/ewk" "${WEBKIT_DIR}/efl/WebCoreSupport" + "${JAVASCRIPTCORE_DIR}/wtf/gobject" "${WEBCORE_DIR}/platform/efl" "${WEBCORE_DIR}/platform/graphics/cairo" ${Cairo_INCLUDE_DIRS} @@ -20,6 +19,8 @@ LIST(APPEND WebKit_INCLUDE_DIRECTORIES ${LIBXML2_INCLUDE_DIR} ${LIBXSLT_INCLUDE_DIR} ${SQLITE_INCLUDE_DIR} + ${Glib_INCLUDE_DIRS} + ${LIBSOUP24_INCLUDE_DIRS} ) IF (ENABLE_SVG) @@ -71,15 +72,20 @@ LIST(APPEND WebKit_SOURCES efl/WebCoreSupport/DumpRenderTreeSupportEfl.cpp efl/WebCoreSupport/EditorClientEfl.cpp efl/WebCoreSupport/FrameLoaderClientEfl.cpp + efl/WebCoreSupport/FrameNetworkingContextEfl.cpp efl/WebCoreSupport/FullscreenVideoControllerEfl.cpp efl/WebCoreSupport/IconDatabaseClientEfl.cpp + efl/WebCoreSupport/StorageTrackerClientEfl.cpp efl/WebCoreSupport/InspectorClientEfl.cpp efl/WebCoreSupport/NotificationPresenterClientEfl.cpp + efl/ewk/ewk_auth.cpp + efl/ewk/ewk_auth_soup.cpp efl/ewk/ewk_contextmenu.cpp efl/ewk/ewk_cookies.cpp efl/ewk/ewk_frame.cpp efl/ewk/ewk_history.cpp + efl/ewk/ewk_js.cpp efl/ewk/ewk_main.cpp efl/ewk/ewk_network.cpp efl/ewk/ewk_security_policy.cpp @@ -92,7 +98,6 @@ LIST(APPEND WebKit_SOURCES efl/ewk/ewk_view_single.cpp efl/ewk/ewk_view_tiled.cpp efl/ewk/ewk_window_features.cpp - efl/ewk/ewk_js.cpp ) LIST(APPEND WebKit_LIBRARIES @@ -106,33 +111,19 @@ LIST(APPEND WebKit_LIBRARIES ${PNG_LIBRARY} ${JPEG_LIBRARY} ${CMAKE_DL_LIBS} -) - -IF (ENABLE_GLIB_SUPPORT) - LIST(APPEND WebKit_INCLUDE_DIRECTORIES - ${Gdk_INCLUDE_DIRS} - ${Glib_INCLUDE_DIRS} - ${JAVASCRIPTCORE_DIR}/wtf/gobject - ) - LIST(APPEND WebKit_LIBRARIES ${Glib_LIBRARIES} - ${Gdk_LIBRARIES} - ) -ENDIF () + ${LIBSOUP24_LIBRARIES} +) -IF (WTF_USE_SOUP) - LIST(APPEND WebKit_INCLUDE_DIRECTORIES ${LIBSOUP24_INCLUDE_DIRS}) - LIST(APPEND WebKit_LIBRARIES ${LIBSOUP24_LIBRARIES}) - LIST(APPEND WebKit_SOURCES - efl/ewk/ewk_auth.cpp - efl/ewk/ewk_auth_soup.cpp - ) +IF (ENABLE_VIBRATION) + LIST(APPEND WebKit_INCLUDE_DIRECTORIES + ${WEBCORE_DIR}/Modules/vibration + ) + LIST(APPEND WebKit_SOURCES + efl/WebCoreSupport/VibrationClientEfl.cpp + ) ENDIF () -IF (WTF_USE_CURL) - LIST(APPEND WebKit_INCLUDE_DIRECTORIES ${CURL_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIRS}) - LIST(APPEND WebKit_LIBRARIES ${CURL_LIBRARIES} ${ZLIB_LIBRARIES}) -ENDIF () SET(WebKit_THEME_DEFINITION "") IF (ENABLE_PROGRESS_TAG) @@ -235,6 +226,7 @@ UNSET(LIBS_PRIVATE) SET(EWebKit_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/EWebKit.h ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_auth.h + ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_auth_soup.h ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_contextmenu.h ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_cookies.h ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_frame.h @@ -249,10 +241,6 @@ SET(EWebKit_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_window_features.h ) -IF (WTF_USE_SOUP) - LIST(APPEND EWebKit_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/efl/ewk/ewk_auth_soup.h) -ENDIF () - INSTALL(FILES ${EWebKit_HEADERS} DESTINATION include/${WebKit_LIBRARY_NAME}-${PROJECT_VERSION_MAJOR}) diff --git a/Source/WebKit/wince/CMakeListsWinCE.txt b/Source/WebKit/PlatformWinCE.cmake index de6de607e..de6de607e 100644 --- a/Source/WebKit/wince/CMakeListsWinCE.txt +++ b/Source/WebKit/PlatformWinCE.cmake diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj index 16cdf4c00..c8de755b6 100644 --- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj +++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj @@ -74,6 +74,9 @@ 226E9E6B09D0AA8200F3A2BC /* WebNetscapeDeprecatedFunctions.c in Sources */ = {isa = PBXBuildFile; fileRef = 226E9E6909D0AA8200F3A2BC /* WebNetscapeDeprecatedFunctions.c */; settings = {COMPILER_FLAGS = "-Wno-deprecated-declarations"; }; }; 22F219CC08D236730030E078 /* WebBackForwardListPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 22F219CB08D236730030E078 /* WebBackForwardListPrivate.h */; settings = {ATTRIBUTES = (Private, ); }; }; 29AEF960134C76FB00FE5096 /* OutlookQuirksUserScript.js in Resources */ = {isa = PBXBuildFile; fileRef = 29AEF95D134C755400FE5096 /* OutlookQuirksUserScript.js */; }; + 312E2FE514E48182007CCA18 /* WebNotification.h in Headers */ = {isa = PBXBuildFile; fileRef = 312E2FE314E48182007CCA18 /* WebNotification.h */; settings = {ATTRIBUTES = (Private, ); }; }; + 312E2FE614E48182007CCA18 /* WebNotification.mm in Sources */ = {isa = PBXBuildFile; fileRef = 312E2FE414E48182007CCA18 /* WebNotification.mm */; }; + 312E2FE914E48215007CCA18 /* WebNotificationInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 312E2FE814E48215007CCA18 /* WebNotificationInternal.h */; }; 31C11A6E1476552E0049A4CC /* WebNotificationClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 31C11A6C1476552E0049A4CC /* WebNotificationClient.h */; }; 31C11A6F1476552E0049A4CC /* WebNotificationClient.mm in Sources */ = {isa = PBXBuildFile; fileRef = 31C11A6D1476552E0049A4CC /* WebNotificationClient.mm */; }; 37B6FB4E1063530C000FDB3B /* WebPDFDocumentExtras.h in Headers */ = {isa = PBXBuildFile; fileRef = 37B6FB4C1063530C000FDB3B /* WebPDFDocumentExtras.h */; }; @@ -456,6 +459,9 @@ 2D36FD5E03F78F9E00A80166 /* WebFormDelegatePrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = WebFormDelegatePrivate.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; }; 2D81DAB203EB0B2D00A80166 /* WebFormDelegate.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = WebFormDelegate.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; }; 2D81DAB303EB0B2D00A80166 /* WebFormDelegate.m */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.objc; path = WebFormDelegate.m; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; }; + 312E2FE314E48182007CCA18 /* WebNotification.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebNotification.h; sourceTree = "<group>"; }; + 312E2FE414E48182007CCA18 /* WebNotification.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebNotification.mm; sourceTree = "<group>"; }; + 312E2FE814E48215007CCA18 /* WebNotificationInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebNotificationInternal.h; sourceTree = "<group>"; }; 31C11A6C1476552E0049A4CC /* WebNotificationClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebNotificationClient.h; sourceTree = "<group>"; }; 31C11A6D1476552E0049A4CC /* WebNotificationClient.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebNotificationClient.mm; sourceTree = "<group>"; }; 35081D9202B6D4D80ACA2ACA /* WebHTMLRepresentation.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; indentWidth = 4; path = WebHTMLRepresentation.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; }; @@ -1239,6 +1245,9 @@ F834AAD60E64B1C700E2737C /* WebTextIterator.mm */, 515E27CC0458C86500CA2D3A /* WebUIDelegate.h */, 65A7D44A0568AB2600E70EF6 /* WebUIDelegatePrivate.h */, + 312E2FE314E48182007CCA18 /* WebNotification.h */, + 312E2FE414E48182007CCA18 /* WebNotification.mm */, + 312E2FE814E48215007CCA18 /* WebNotificationInternal.h */, 51A8B579042834F700CA2D3A /* WebView.h */, 51A8B57A042834F700CA2D3A /* WebView.mm */, BC2E464B0FD8A96800A9D9DE /* WebViewData.h */, @@ -1632,6 +1641,8 @@ 9398109B0824BF01008DF038 /* WebViewInternal.h in Headers */, 939810710824BF01008DF038 /* WebViewPrivate.h in Headers */, 41F4484F10338E8C0030E55E /* WebWorkersPrivate.h in Headers */, + 312E2FE514E48182007CCA18 /* WebNotification.h in Headers */, + 312E2FE914E48215007CCA18 /* WebNotificationInternal.h in Headers */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -2018,6 +2029,7 @@ 939811070824BF01008DF038 /* WebView.mm in Sources */, BC2E464E0FD8A96800A9D9DE /* WebViewData.mm in Sources */, 41F4485010338E8C0030E55E /* WebWorkersPrivate.mm in Sources */, + 312E2FE614E48182007CCA18 /* WebNotification.mm in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/Source/WebKit/blackberry/Api/ActiveNodeContext.h b/Source/WebKit/blackberry/Api/ActiveNodeContext.h new file mode 100644 index 000000000..1258d259f --- /dev/null +++ b/Source/WebKit/blackberry/Api/ActiveNodeContext.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef ActiveNodeContext_h +#define ActiveNodeContext_h + +#include "WebString.h" + +namespace BlackBerry { +namespace WebKit { + +class ActiveNodeContext { +public: + // We assume a default context should be selectable, but nothing else. + ActiveNodeContext() + : m_flags(IsSelectable) + { + } + + enum ContextFlags { IsFocusable = 0x01, + IsInput = 0x02, + IsPassword = 0x04, + IsSelectable = 0x08, + IsSingleLine = 0x10, }; + + bool isFocusable() const { return m_flags & IsFocusable; } + bool isInput() const { return m_flags & IsInput; } + bool isPassword() const { return m_flags & IsPassword; } + bool isSelectable() const { return m_flags & IsSelectable; } + bool isSingleLine() const { return m_flags & IsSingleLine; } + + void setFlag(ContextFlags flag) { m_flags |= flag; } + void resetFlag(ContextFlags flag) { m_flags &= ~flag; } + + const WebString& imageAlt() const { return m_imageAlt; } + void setImageAlt(const WebString& string) { m_imageAlt = string; } + + const WebString& imageSrc() const { return m_imageSrc; } + void setImageSrc(const WebString& string) { m_imageSrc = string; } + + const WebString& pattern() const { return m_pattern; } + void setPattern(const WebString& string) { m_pattern = string; } + + const WebString& text() const { return m_text; } + void setText(const WebString& string) { m_text = string; } + + const WebString& url() const { return m_url; } + void setUrl(const WebString& string) { m_url = string; } + +private: + unsigned m_flags; + WebString m_imageAlt; + WebString m_imageSrc; + WebString m_pattern; + WebString m_text; + WebString m_url; +}; + +} +} +#endif // ActiveNodeContext_h diff --git a/Source/WebKit/blackberry/Api/BackingStore.cpp b/Source/WebKit/blackberry/Api/BackingStore.cpp index 036c9bbc0..2971d2698 100644 --- a/Source/WebKit/blackberry/Api/BackingStore.cpp +++ b/Source/WebKit/blackberry/Api/BackingStore.cpp @@ -39,6 +39,7 @@ #include <BlackBerryPlatformIntRectRegion.h> #include <BlackBerryPlatformMessage.h> #include <BlackBerryPlatformMessageClient.h> +#include <BlackBerryPlatformWindow.h> #include <wtf/CurrentTime.h> #include <wtf/MathExtras.h> @@ -54,11 +55,6 @@ #define DEBUG_TILEMATRIX 0 #define DEBUG_COMPOSITING_DIRTY_REGION 0 -#if USE(OPENVG) -#include "EGLDisplayOpenVG.h" -#include "EGLUtils.h" -#endif - #include <BlackBerryPlatformScreen.h> using namespace WebCore; @@ -202,9 +198,6 @@ BackingStorePrivate::BackingStorePrivate() , m_renderQueue(adoptPtr(new RenderQueue(this))) , m_defersBlit(true) , m_hasBlitJobs(false) -#if USE(OPENVG) - , m_eglDisplay(EGL_NO_DISPLAY) -#endif , m_currentWindowBackBuffer(0) , m_preferredTileMatrixDimension(Vertical) , m_blitGeneration(-1) @@ -298,10 +291,6 @@ void BackingStorePrivate::resumeScreenAndBackingStoreUpdates(BackingStore::Resum void BackingStorePrivate::repaint(const Platform::IntRect& windowRect, bool contentChanged, bool immediate) { -#if USE(OPENVG) - ASSERT(m_eglDisplay != EGL_NO_DISPLAY); -#endif - if (m_suspendBackingStoreUpdates) return; @@ -2215,9 +2204,6 @@ void BackingStorePrivate::renderContents(BlackBerry::Platform::Graphics::Buffer* } // Grab the requested region from the drawing surface into the tile image. -#if USE(OPENVG) - surface->makeCurrent(); -#endif delete bufferPlatformGraphicsContext; @@ -2525,23 +2511,9 @@ void BackingStore::createSurface() initialized = true; } -#if USE(OPENVG) - d->m_eglDisplay = BlackBerry::Platform::Graphics::eglDisplay(); - - // Make sure we are using OpenVG. - eglBindAPI(EGL_OPENVG_API); - ASSERT_EGL_NO_ERROR(); - - EGLDisplayOpenVG::setCurrentDisplay(d->m_eglDisplay); -#endif - // Triggers creation of surfaces in backingstore. d->createSurfaces(); -#if USE(OPENVG) - EGLDisplayOpenVG::current()->sharedPlatformSurface()->makeCurrent(); -#endif - // Focusing the WebPage triggers a repaint, so while we want it to be // focused initially this has to happen after creation of the surface. d->m_webPage->setFocused(true); diff --git a/Source/WebKit/blackberry/Api/BackingStore_p.h b/Source/WebKit/blackberry/Api/BackingStore_p.h index 30abb592d..49c70a6a5 100644 --- a/Source/WebKit/blackberry/Api/BackingStore_p.h +++ b/Source/WebKit/blackberry/Api/BackingStore_p.h @@ -29,10 +29,6 @@ #include <wtf/HashMap.h> #include <wtf/Vector.h> -#if USE(OPENVG) -#include <egl.h> -#endif - #include <pthread.h> namespace WebCore { @@ -332,9 +328,6 @@ public: bool m_defersBlit; bool m_hasBlitJobs; -#if USE(OPENVG) - EGLDisplay m_eglDisplay; -#endif mutable unsigned m_frontState; mutable unsigned m_backState; diff --git a/Source/WebKit/blackberry/Api/BlackBerryGlobal.cpp b/Source/WebKit/blackberry/Api/BlackBerryGlobal.cpp new file mode 100644 index 000000000..6258a3cc3 --- /dev/null +++ b/Source/WebKit/blackberry/Api/BlackBerryGlobal.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "BlackBerryGlobal.h" + +#include "ApplicationCacheStorage.h" +#include "CacheClientBlackBerry.h" +#include "CookieManager.h" +#include "CrossOriginPreflightResultCache.h" +#include "FontCache.h" +#include "ImageSource.h" +#include "InitializeThreading.h" +#include "JSDOMWindow.h" +#include "JSGlobalData.h" +#include "Logging.h" +#include "MainThread.h" +#include "MemoryCache.h" +#include "NetworkStateNotifier.h" +#include "PageCache.h" +#include "PageGroup.h" +#include "TextureCacheCompositingThread.h" +#include "WebString.h" +#include "bindings/js/GCController.h" +#include "runtime/JSLock.h" +#include <BlackBerryPlatformExecutableMessage.h> +#include <BlackBerryPlatformMessageClient.h> +#include <BlackBerryPlatformSettings.h> + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { + +static bool gIsGlobalInitialized = false; + +// Global initialization of various WebKit singletons. +void globalInitialize() +{ + if (gIsGlobalInitialized) + return; + gIsGlobalInitialized = true; + +#if ENABLE(BLACKBERRY_DEBUG_MEMORY) + blackberryDebugInitialize(); +#endif + + // Turn on logging. + initializeLoggingChannelsIfNecessary(); + + // Initialize threading/ + JSC::initializeThreading(); + + // Normally this is called from initializeThreading, but we're using ThreadingNone + // we're grabbing callOnMainThread without using the rest of the threading support. + WTF::initializeMainThread(); + + // Track visited links. + PageGroup::setShouldTrackVisitedLinks(true); + + CacheClientBlackBerry::get()->initialize(); + + BlackBerry::Platform::Settings* settings = BlackBerry::Platform::Settings::get(); + + ImageSource::setMaxPixelsPerDecodedImage(settings->maxPixelsPerDecodedImage()); +} + +void collectJavascriptGarbageNow() +{ + if (gIsGlobalInitialized) + gcController().garbageCollectNow(); +} + +void clearCookieCache() +{ + cookieManager().removeAllCookies(RemoveFromBackingStore); +} + +#if USE(ACCELERATED_COMPOSITING) +static void clearMemoryCachesInCompositingThread() +{ + textureCacheCompositingThread()->prune(0); +} +#endif + +void clearMemoryCaches() +{ +#if USE(ACCELERATED_COMPOSITING) + // Call textureCacheCompositingThread()->prune(0) in UI thread. + BlackBerry::Platform::userInterfaceThreadMessageClient()->dispatchMessage(BlackBerry::Platform::createFunctionCallMessage(clearMemoryCachesInCompositingThread)); +#endif + + { + JSC::JSLock lock(JSC::SilenceAssertionsOnly); + // This function also performs a GC. + JSC::releaseExecutableMemory(*JSDOMWindow::commonJSGlobalData()); + } + + // Clean caches after JS garbage collection because JS GC can + // generate more dead resources. + int capacity = pageCache()->capacity(); + pageCache()->setCapacity(0); + pageCache()->setCapacity(capacity); + pageCache()->releaseAutoreleasedPagesNow(); + + CrossOriginPreflightResultCache::shared().empty(); + + if (!memoryCache()->disabled()) { + // Evict all dead resources and prune live resources. + memoryCache()->setCapacities(0, 0, 0); + + // Update cache capacity based on current memory status. + CacheClientBlackBerry::get()->updateCacheCapacity(); + } + + fontCache()->invalidate(); +} + +void clearAppCache(const WebString& pageGroupName) +{ + cacheStorage().empty(); +} + +void clearLocalStorage(const WebString& pageGroupName) +{ +} + +void clearDatabase(const WebString& pageGroupName) +{ +} + +void updateOnlineStatus(bool online) +{ + networkStateNotifier().networkStateChange(online); +} + +} +} diff --git a/Source/WebKit/blackberry/Api/BlackBerryGlobal.h b/Source/WebKit/blackberry/Api/BlackBerryGlobal.h new file mode 100644 index 000000000..e794fb951 --- /dev/null +++ b/Source/WebKit/blackberry/Api/BlackBerryGlobal.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef BlackBerryGlobal_h +#define BlackBerryGlobal_h + +#if defined(__QNXNTO__) && defined(BUILD_WEBKIT) + #define BLACKBERRY_EXPORT __attribute__ ((visibility("default"))) +#else + #define BLACKBERRY_EXPORT +#endif + +namespace BlackBerry { +namespace WebKit { + +class WebString; + +void globalInitialize(); +void collectJavascriptGarbageNow(); +void clearCookieCache(); +BLACKBERRY_EXPORT void clearMemoryCaches(); +void clearAppCache(const WebString& pageGroupName); +void reopenAllAppCaches(); +void closeAllAppCaches(); +void clearLocalStorage(const WebString& pageGroupName); +void closeAllLocalStorages(); +void clearDatabase(const WebString& pageGroupName); +void reopenAllTrackerDatabases(); +void closeAllTrackerDatabases(); +void updateOnlineStatus(bool online); +} +} + +#endif // BlackBerryGlobal_h diff --git a/Source/WebKit/blackberry/Api/Version.cpp b/Source/WebKit/blackberry/Api/Version.cpp new file mode 100644 index 000000000..23e7b7bd5 --- /dev/null +++ b/Source/WebKit/blackberry/Api/Version.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "Version.h" + +#include "WebKitVersion.h" // Note: auto generated at build time. + +// Make sure we are not treated as big endian nor middle endian. +#if PLATFORM(ARM) && (PLATFORM(BIG_ENDIAN) || PLATFORM(MIDDLE_ENDIAN)) +#error Our platform is little endian, but either PLATFORM(BIG_ENDIAN) or PLATFORM(MIDDLE_ENDIAN) is defined! +#endif + +namespace BlackBerry { +namespace WebKit { + +int webKitMajorVersion() +{ + return WEBKIT_MAJOR_VERSION; +} + +int webKitMinorVersion() +{ + return WEBKIT_MINOR_VERSION; +} + +} +} diff --git a/Source/WebKit/blackberry/Api/Version.h b/Source/WebKit/blackberry/Api/Version.h new file mode 100644 index 000000000..eedd7da8d --- /dev/null +++ b/Source/WebKit/blackberry/Api/Version.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2010, 2011 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef Version_h +#define Version_h + +namespace BlackBerry { +namespace WebKit { +int webKitMajorVersion(); +int webKitMinorVersion(); +} +} + +#endif // Version_h diff --git a/Source/WebKit/blackberry/Api/WebKitMIMETypeConverter.cpp b/Source/WebKit/blackberry/Api/WebKitMIMETypeConverter.cpp new file mode 100644 index 000000000..9c98af4e3 --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebKitMIMETypeConverter.cpp @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "WebKitMIMETypeConverter.h" + +#include "MIMETypeRegistry.h" +#include <wtf/text/CString.h> +#include <wtf/text/WTFString.h> + +namespace BlackBerry { +namespace WebKit { + +bool getExtensionForMimeType(const std::string& mime, std::string& extension) +{ + String mimeType(mime.data(), mime.length()); + String preferredExtension = WebCore::MIMETypeRegistry::getPreferredExtensionForMIMEType(mimeType); + if (preferredExtension.isEmpty()) + return false; + + CString utf8 = preferredExtension.utf8(); + extension.clear(); + extension.append(utf8.data(), utf8.length()); + return true; +} + +bool getMimeTypeForExtension(const std::string& extension, std::string& mimeType) +{ + String extStr(extension.data(), extension.length()); + String mime = WebCore::MIMETypeRegistry::getMediaMIMETypeForExtension(extStr); + if (mime.isEmpty()) + return false; + + CString utf8 = mime.utf8(); + mimeType.clear(); + mimeType.append(utf8.data(), utf8.length()); + return true; +} + +} // namespace WebKit +} // namespace BlackBerry diff --git a/Source/WebKit/blackberry/Api/WebKitMIMETypeConverter.h b/Source/WebKit/blackberry/Api/WebKitMIMETypeConverter.h new file mode 100644 index 000000000..3ff3d74f9 --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebKitMIMETypeConverter.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebKitMIMETypeConverter_h +#define WebKitMIMETypeConverter_h + +#include "BlackBerryGlobal.h" +#include <string> + +namespace BlackBerry { +namespace WebKit { + +BLACKBERRY_EXPORT bool getExtensionForMimeType(const std::string& mime, std::string& extension); +BLACKBERRY_EXPORT bool getMimeTypeForExtension(const std::string& extension, std::string& mimeType); + +} // namespace WebKit +} // namespace BlackBerry + +#endif // WebKitMIMETypeConverter_h diff --git a/Source/WebKit/blackberry/Api/WebKitTextCodec.cpp b/Source/WebKit/blackberry/Api/WebKitTextCodec.cpp index badb31fc7..3250601dd 100644 --- a/Source/WebKit/blackberry/Api/WebKitTextCodec.cpp +++ b/Source/WebKit/blackberry/Api/WebKitTextCodec.cpp @@ -21,7 +21,6 @@ #include "Base64.h" #include "KURL.h" -#include "MIMETypeRegistry.h" #include "TextCodecICU.h" #include <wtf/Vector.h> #include <wtf/text/CString.h> @@ -134,18 +133,5 @@ void escapeURL(const std::string& url, std::string& escaped) escaped.append(utf8.data(), utf8.length()); } -bool getExtensionForMimeType(const std::string& mime, std::string& extension) -{ - String mimeType(mime.data(), mime.length()); - String preferredExtension = WebCore::MIMETypeRegistry::getPreferredExtensionForMIMEType(mimeType); - if (preferredExtension.isEmpty()) - return false; - - CString utf8 = preferredExtension.utf8(); - extension.clear(); - extension.append(utf8.data(), utf8.length()); - return true; -} - } // namespace WebKit } // namespace BlackBerry diff --git a/Source/WebKit/blackberry/Api/WebKitTextCodec.h b/Source/WebKit/blackberry/Api/WebKitTextCodec.h index 318411a87..2834be793 100644 --- a/Source/WebKit/blackberry/Api/WebKitTextCodec.h +++ b/Source/WebKit/blackberry/Api/WebKitTextCodec.h @@ -55,8 +55,6 @@ BLACKBERRY_EXPORT bool base64Encode(const std::vector<char>& binary, std::string BLACKBERRY_EXPORT void unescapeURL(const std::string& escaped, std::string& url); BLACKBERRY_EXPORT void escapeURL(const std::string& url, std::string& escaped); -BLACKBERRY_EXPORT bool getExtensionForMimeType(const std::string& mime, std::string& extension); - } // namespace WebKit } // namespace BlackBerry diff --git a/Source/WebKit/blackberry/Api/WebPage.cpp b/Source/WebKit/blackberry/Api/WebPage.cpp new file mode 100644 index 000000000..f3ce5f0ce --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebPage.cpp @@ -0,0 +1,5598 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "WebPage.h" + +#include "ApplicationCacheStorage.h" +#include "BackForwardController.h" +#include "BackForwardListImpl.h" +#include "BackingStoreClient.h" +#include "BackingStoreCompositingSurface.h" +#include "BackingStore_p.h" +#include "CString.h" +#include "CachedImage.h" +#include "Chrome.h" +#include "ChromeClientBlackBerry.h" +#include "ContextMenuClientBlackBerry.h" +#include "CookieManager.h" +#include "DOMSupport.h" +#include "Database.h" +#include "DatabaseSync.h" +#include "DatabaseTracker.h" +#include "DeviceMotionClientBlackBerry.h" +#include "DeviceOrientationClientBlackBerry.h" +#include "DragClientBlackBerry.h" +// FIXME: We should be using DumpRenderTreeClient, but I'm not sure where we should +// create the DRT_BB object. See PR #120355. +#if ENABLE_DRT +#include "DumpRenderTreeBlackBerry.h" +#endif +#include "EditorClientBlackBerry.h" +#include "FocusController.h" +#include "FrameLoaderClientBlackBerry.h" +#if ENABLE(CLIENT_BASED_GEOLOCATION) +#if ENABLE_DRT +#include "GeolocationClientMock.h" +#endif +#include "GeolocationControllerClientBlackBerry.h" +#endif +#include "GroupSettings.h" +#include "HTMLAreaElement.h" +#include "HTMLFrameOwnerElement.h" +#include "HTMLImageElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "HTMLParserIdioms.h" +#include "HTTPParsers.h" +#include "HistoryItem.h" +#include "IconDatabaseClientBlackBerry.h" +#include "InPageSearchManager.h" +#include "InRegionScrollableArea.h" +#include "InputHandler.h" +#include "InspectorBackendDispatcher.h" +#include "InspectorClientBlackBerry.h" +#include "InspectorController.h" +#include "JavaScriptDebuggerBlackBerry.h" +#include "LayerWebKitThread.h" +#include "NetworkManager.h" +#include "NodeRenderStyle.h" +#include "Page.h" +#include "PageCache.h" +#include "PageGroup.h" +#include "PlatformTouchEvent.h" +#include "PlatformWheelEvent.h" +#include "PluginDatabase.h" +#include "PluginView.h" +#include "RenderText.h" +#include "RenderThemeBlackBerry.h" +#include "RenderTreeAsText.h" +#include "RenderView.h" +#include "RenderWidget.h" +#include "ScriptSourceCode.h" +#include "ScriptValue.h" +#include "ScrollTypes.h" +#include "SelectionHandler.h" +#include "Settings.h" +#include "Storage.h" +#include "StorageNamespace.h" +#include "SurfacePool.h" +#include "Text.h" +#include "ThreadCheck.h" +#include "TouchEventHandler.h" +#include "TransformationMatrix.h" +#include "VisiblePosition.h" +#if ENABLE(WEBDOM) +#include "WebDOMDocument.h" +#endif +#include "WebPageClient.h" +#include "WebSocket.h" +#include "npapi.h" +#include "runtime_root.h" + +#if ENABLE(VIDEO) +#include "HTMLMediaElement.h" +#include "MediaPlayer.h" +#include "MediaPlayerPrivateBlackBerry.h" +#endif + +#if USE(SKIA) +#include "PlatformContextSkia.h" +#endif + +#if USE(ACCELERATED_COMPOSITING) +#include "FrameLayers.h" +#include "WebPageCompositor.h" +#endif + +#include <BlackBerryPlatformExecutableMessage.h> +#include <BlackBerryPlatformITPolicy.h> +#include <BlackBerryPlatformKeyboardEvent.h> +#include <BlackBerryPlatformMessageClient.h> +#include <BlackBerryPlatformMouseEvent.h> +#include <BlackBerryPlatformScreen.h> +#include <BlackBerryPlatformSettings.h> +#include <JavaScriptCore/APICast.h> +#include <JavaScriptCore/JSContextRef.h> +#include <SharedPointer.h> +#include <sys/keycodes.h> +#include <unicode/ustring.h> // platform ICU + +#ifndef USER_PROCESSES +#include <memalloc.h> +#endif + +#if ENABLE(SKIA_GPU_CANVAS) +#include "BlackBerryPlatformGraphics.h" +#include "GrContext.h" +#endif + +#define DEBUG_BLOCK_ZOOM 0 +#define DEBUG_TOUCH_EVENTS 0 +#define DEBUG_WEBPAGE_LOAD 0 + +using namespace std; +using namespace WebCore; + +typedef const unsigned short* CUShortPtr; + +namespace BlackBerry { +namespace WebKit { + +static Vector<WebPage*>* visibleWebPages() +{ + static Vector<WebPage*>* s_visibleWebPages = 0; // Initially, no web page is visible. + if (!s_visibleWebPages) + s_visibleWebPages = new Vector<WebPage*>; + return s_visibleWebPages; +} + +const unsigned blockZoomMargin = 3; // Add 3 pixel margin on each side. +static int blockClickRadius = 0; +static double maximumBlockZoomScale = 3; // This scale can be clamped by the maximumScale set for the page. + +const double manualScrollInterval = 0.1; // The time interval during which we associate user action with scrolling. + +const double delayedZoomInterval = 0; + +const IntSize minimumLayoutSize(10, 10); // Needs to be a small size, greater than 0, that we can grow the layout from. +const IntSize maximumLayoutSize(10000, 10000); // Used with viewport meta tag, but we can still grow from this of course. + +const double minimumExpandingRatio = 0.15; + +// Helper function to parse a URL and fill in missing parts. +static KURL parseUrl(const String& url) +{ + String urlString(url); + KURL kurl = KURL(KURL(), urlString); + if (kurl.protocol().isEmpty()) { + urlString.insert("http://", 0); + kurl = KURL(KURL(), urlString); + } + + return kurl; +} + +// Helper functions to convert to and from WebCore types. +static inline MouseEventType toWebCoreMouseEventType(const Platform::MouseEvent::Type type) +{ + switch (type) { + case Platform::MouseEvent::MouseButtonDown: + return MouseEventPressed; + case Platform::MouseEvent::MouseButtonUp: + return MouseEventReleased; + case Platform::MouseEvent::MouseMove: + default: + return MouseEventMoved; + } +} + +static inline ResourceRequestCachePolicy toWebCoreCachePolicy(Platform::NetworkRequest::CachePolicy policy) +{ + switch (policy) { + case Platform::NetworkRequest::UseProtocolCachePolicy: + return UseProtocolCachePolicy; + case Platform::NetworkRequest::ReloadIgnoringCacheData: + return ReloadIgnoringCacheData; + case Platform::NetworkRequest::ReturnCacheDataElseLoad: + return ReturnCacheDataElseLoad; + case Platform::NetworkRequest::ReturnCacheDataDontLoad: + return ReturnCacheDataDontLoad; + default: + ASSERT_NOT_REACHED(); + return UseProtocolCachePolicy; + } +} + +#if ENABLE(EVENT_MODE_METATAGS) +static inline Platform::CursorEventMode toPlatformCursorEventMode(CursorEventMode mode) +{ + switch (mode) { + case ProcessedCursorEvents: + return Platform::ProcessedCursorEvents; + case NativeCursorEvents: + return Platform::NativeCursorEvents; + default: + ASSERT_NOT_REACHED(); + return Platform::ProcessedCursorEvents; + } +} + +static inline Platform::TouchEventMode toPlatformTouchEventMode(TouchEventMode mode) +{ + switch (mode) { + case ProcessedTouchEvents: + return Platform::ProcessedTouchEvents; + case NativeTouchEvents: + return Platform::NativeTouchEvents; + case PureTouchEventsWithMouseConversion: + return Platform::PureTouchEventsWithMouseConversion; + default: + ASSERT_NOT_REACHED(); + return Platform::ProcessedTouchEvents; + } +} +#endif + +static inline HistoryItem* historyItemFromBackForwardId(WebPage::BackForwardId id) +{ + return reinterpret_cast<HistoryItem*>(id); +} + +static inline WebPage::BackForwardId backForwardIdFromHistoryItem(HistoryItem* item) +{ + return reinterpret_cast<WebPage::BackForwardId>(item); +} + +WebPagePrivate::WebPagePrivate(WebPage* webPage, WebPageClient* client, const IntRect& rect) + : m_webPage(webPage) + , m_client(client) + , m_page(0) // Initialized by init. + , m_mainFrame(0) // Initialized by init. + , m_currentContextNode(0) + , m_webSettings(0) // Initialized by init. + , m_visible(false) + , m_shouldResetTilesWhenShown(false) + , m_userScalable(true) + , m_userPerformedManualZoom(false) + , m_userPerformedManualScroll(false) + , m_contentsSizeChanged(false) + , m_overflowExceedsContentsSize(false) + , m_resetVirtualViewportOnCommitted(true) + , m_shouldUseFixedDesktopMode(false) + , m_needTouchEvents(false) + , m_preventIdleDimmingCount(0) +#if ENABLE(TOUCH_EVENTS) + , m_preventDefaultOnTouchStart(false) +#endif + , m_nestedLayoutFinishedCount(0) + , m_actualVisibleWidth(rect.width()) + , m_actualVisibleHeight(rect.height()) + , m_virtualViewportWidth(0) + , m_virtualViewportHeight(0) + , m_defaultLayoutSize(minimumLayoutSize) + , m_didRestoreFromPageCache(false) + , m_viewMode(WebPagePrivate::Desktop) // Default to Desktop mode for PB. + , m_loadState(WebPagePrivate::None) + , m_transformationMatrix(new TransformationMatrix()) + , m_backingStore(0) // Initialized by init. + , m_backingStoreClient(0) // Initialized by init. + , m_inPageSearchManager(new InPageSearchManager(this)) + , m_inputHandler(new InputHandler(this)) + , m_selectionHandler(new SelectionHandler(this)) + , m_touchEventHandler(new TouchEventHandler(this)) +#if ENABLE(EVENT_MODE_METATAGS) + , m_cursorEventMode(ProcessedCursorEvents) + , m_touchEventMode(ProcessedTouchEvents) +#endif + , m_currentCursor(Platform::CursorNone) + , m_dumpRenderTree(0) // Lazy initialization. + , m_initialScale(-1.0) + , m_minimumScale(-1.0) + , m_maximumScale(-1.0) + , m_blockZoomFinalScale(1.0) + , m_anchorInNodeRectRatio(-1, -1) + , m_currentBlockZoomNode(0) + , m_currentBlockZoomAdjustedNode(0) + , m_shouldReflowBlock(false) + , m_delayedZoomTimer(adoptPtr(new Timer<WebPagePrivate>(this, &WebPagePrivate::zoomAboutPointTimerFired))) + , m_lastUserEventTimestamp(0.0) + , m_pluginMouseButtonPressed(false) + , m_pluginMayOpenNewTab(false) + , m_geolocationClient(0) + , m_inRegionScrollStartingNode(0) +#if USE(ACCELERATED_COMPOSITING) + , m_isAcceleratedCompositingActive(false) + , m_rootLayerCommitTimer(adoptPtr(new Timer<WebPagePrivate>(this, &WebPagePrivate::rootLayerCommitTimerFired))) + , m_needsOneShotDrawingSynchronization(false) + , m_needsCommit(false) + , m_suspendRootLayerCommit(false) +#endif + , m_pendingOrientation(-1) + , m_fullscreenVideoNode(0) + , m_hasInRegionScrollableAreas(false) + , m_updateDelegatedOverlaysDispatched(false) +{ +} + +WebPagePrivate::~WebPagePrivate() +{ + // Hand the backingstore back to another owner if necessary. + m_webPage->setVisible(false); + if (BackingStorePrivate::currentBackingStoreOwner() == m_webPage) + BackingStorePrivate::setCurrentBackingStoreOwner(0); + + delete m_webSettings; + m_webSettings = 0; + + delete m_backingStoreClient; + m_backingStoreClient = 0; + m_backingStore = 0; + + delete m_page; + m_page = 0; + + delete m_transformationMatrix; + m_transformationMatrix = 0; + + delete m_inPageSearchManager; + m_inPageSearchManager = 0; + + delete m_selectionHandler; + m_selectionHandler = 0; + + delete m_inputHandler; + m_inputHandler = 0; + + delete m_touchEventHandler; + m_touchEventHandler = 0; + +#if ENABLE_DRT + delete m_dumpRenderTree; + m_dumpRenderTree = 0; +#endif +} + +void WebPagePrivate::init(const WebString& pageGroupName) +{ + ChromeClientBlackBerry* chromeClient = new ChromeClientBlackBerry(this); + ContextMenuClientBlackBerry* contextMenuClient = 0; +#if ENABLE(CONTEXT_MENUS) + contextMenuClient = new ContextMenuClientBlackBerry(); +#endif + EditorClientBlackBerry* editorClient = new EditorClientBlackBerry(this); + DragClientBlackBerry* dragClient = 0; +#if ENABLE(DRAG_SUPPORT) + dragClient = new DragClientBlackBerry(); +#endif + InspectorClientBlackBerry* inspectorClient = 0; +#if ENABLE(INSPECTOR) + inspectorClient = new InspectorClientBlackBerry(this); +#endif + + FrameLoaderClientBlackBerry* frameLoaderClient = new FrameLoaderClientBlackBerry(); + + Page::PageClients pageClients; + pageClients.chromeClient = chromeClient; + pageClients.contextMenuClient = contextMenuClient; + pageClients.editorClient = editorClient; + pageClients.dragClient = dragClient; + pageClients.inspectorClient = inspectorClient; + +#if ENABLE(CLIENT_BASED_GEOLOCATION) + // Note the object will be destroyed when the page is destroyed. +#if ENABLE_DRT + if (getenv("drtRun")) + pageClients.geolocationClient = new GeolocationClientMock(); + else +#endif + pageClients.geolocationClient = m_geolocationClient = new GeolocationControllerClientBlackBerry(this); +#else + pageClients.geolocationClient = m_geolocationClient; +#endif + + pageClients.deviceMotionClient = new DeviceMotionClientBlackBerry(this); + pageClients.deviceOrientationClient = new DeviceOrientationClientBlackBerry(this); + m_page = new Page(pageClients); + +#if ENABLE(CLIENT_BASED_GEOLOCATION) && ENABLE_DRT + // In case running in DumpRenderTree mode set the controller to mock provider. + if (getenv("drtRun")) + static_cast<GeolocationClientMock*>(pageClients.geolocationClient)->setController(m_page->geolocationController()); +#endif + + m_page->setCustomHTMLTokenizerChunkSize(256); + m_page->setCustomHTMLTokenizerTimeDelay(0.3); + + m_webSettings = WebSettings::createFromStandardSettings(); + + // FIXME: We explicitly call setDelegate() instead of passing ourself in createFromStandardSettings() + // so that we only get one didChangeSettings() callback when we set the page group name. This causes us + // to make a copy of the WebSettings since some WebSettings method make use of the page group name. + // Instead, we shouldn't be storing the page group name in WebSettings. + m_webSettings->setDelegate(this); + m_webSettings->setPageGroupName(pageGroupName); + + RefPtr<Frame> newFrame = Frame::create(m_page, /* HTMLFrameOwnerElement* */ 0, frameLoaderClient); + + m_mainFrame = newFrame.get(); + frameLoaderClient->setFrame(m_mainFrame, this); + m_mainFrame->init(); + +#if ENABLE(WEBGL) + Platform::Settings* settings = Platform::Settings::get(); + m_page->settings()->setWebGLEnabled(settings && settings->isWebGLSupported()); +#endif +#if ENABLE(SKIA_GPU_CANVAS) + m_page->settings()->setCanvasUsesAcceleratedDrawing(true); + m_page->settings()->setAccelerated2dCanvasEnabled(true); +#endif +#if ENABLE(VIEWPORT_REFLOW) + m_page->settings()->setTextReflowEnabled(m_webSettings->textReflowMode() == WebSettings::TextReflowEnabled); +#endif + + m_page->settings()->setUseHixie76WebSocketProtocol(false); + m_page->settings()->setInteractiveFormValidationEnabled(true); + m_page->settings()->setAllowUniversalAccessFromFileURLs(false); + + m_backingStoreClient = BackingStoreClient::create(m_mainFrame, /* parent frame */ 0, m_webPage); + // The direct access to BackingStore is left here for convenience since it + // is owned by BackingStoreClient and then deleted by its destructor. + m_backingStore = m_backingStoreClient->backingStore(); + + m_page->settings()->setSpatialNavigationEnabled(m_webSettings->isSpatialNavigationEnabled()); + blockClickRadius = int(roundf(0.35 * Platform::Graphics::Screen::pixelsPerInch(0).width())); // The clicked rectangle area should be a fixed unit of measurement. + + m_page->settings()->setDelegateSelectionPaint(true); +} + +void WebPagePrivate::load(const char* url, const char* networkToken, const char* method, Platform::NetworkRequest::CachePolicy cachePolicy, const char* data, size_t dataLength, const char* const* headers, size_t headersLength, bool isInitial, bool mustHandleInternally, bool forceDownload, const char* overrideContentType) +{ + stopCurrentLoad(); + + String urlString(url); + if (urlString.startsWith("vs:", false)) { + urlString = urlString.substring(3); + m_mainFrame->setInViewSourceMode(true); + } else + m_mainFrame->setInViewSourceMode(false); + + KURL kurl = parseUrl(urlString); + if (protocolIs(kurl, "javascript")) { + // Never run javascript while loading is deferred. + if (m_page->defersLoading()) { + FrameLoaderClientBlackBerry* frameLoaderClient = static_cast<FrameLoaderClientBlackBerry*>(m_mainFrame->loader()->client()); + frameLoaderClient->setDeferredManualScript(kurl); + } else + m_mainFrame->script()->executeIfJavaScriptURL(kurl, DoNotReplaceDocumentIfJavaScriptURL); + return; + } + + if (isInitial) + NetworkManager::instance()->setInitialURL(kurl); + + ResourceRequest request(kurl, "" /* referrer */); + request.setToken(networkToken); + if (isInitial || mustHandleInternally) + request.setMustHandleInternally(true); + request.setHTTPMethod(method); + request.setCachePolicy(toWebCoreCachePolicy(cachePolicy)); + if (overrideContentType) + request.setOverrideContentType(overrideContentType); + + if (data) + request.setHTTPBody(FormData::create(data, dataLength)); + + for (unsigned i = 0; i + 1 < headersLength; i += 2) + request.addHTTPHeaderField(headers[i], headers[i + 1]); + + if (forceDownload) + request.setForceDownload(true); + + m_mainFrame->loader()->load(request, "" /* name */, false); +} + +void WebPagePrivate::loadString(const char* string, const char* baseURL, const char* contentType, const char* failingURL) +{ + KURL kurl = parseUrl(baseURL); + ResourceRequest request(kurl); + WTF::RefPtr<SharedBuffer> buffer + = SharedBuffer::create(string, strlen(string)); + SubstituteData substituteData(buffer, + extractMIMETypeFromMediaType(contentType), + extractCharsetFromMediaType(contentType), + failingURL ? parseUrl(failingURL) : KURL()); + m_mainFrame->loader()->load(request, substituteData, false); +} + +bool WebPagePrivate::executeJavaScript(const char* script, JavaScriptDataType& returnType, WebString& returnValue) +{ + ScriptValue result = m_mainFrame->script()->executeScript(String::fromUTF8(script), false); + JSC::JSValue value = result.jsValue(); + if (!value) { + returnType = JSException; + return false; + } + + JSC::ExecState* exec = m_mainFrame->script()->globalObject(mainThreadNormalWorld())->globalExec(); + JSGlobalContextRef context = toGlobalRef(exec); + + JSType type = JSValueGetType(context, toRef(exec, value)); + + switch (type) { + case kJSTypeNull: + returnType = JSNull; + break; + case kJSTypeBoolean: + returnType = JSBoolean; + break; + case kJSTypeNumber: + returnType = JSNumber; + break; + case kJSTypeString: + returnType = JSString; + break; + case kJSTypeObject: + returnType = JSObject; + break; + case kJSTypeUndefined: + default: + returnType = JSUndefined; + break; + } + + if (returnType == JSBoolean || returnType == JSNumber || returnType == JSString || returnType == JSObject) { + String str = result.toString(exec); + returnValue = WebString(str.impl()); + } + + return true; +} + +bool WebPagePrivate::executeJavaScriptInIsolatedWorld(const ScriptSourceCode& sourceCode, JavaScriptDataType& returnType, WebString& returnValue) +{ + if (!m_isolatedWorld) + m_isolatedWorld = m_mainFrame->script()->createWorld(); + + // Use evaluateInWorld to avoid canExecuteScripts check. + ScriptValue result = m_mainFrame->script()->evaluateInWorld(sourceCode, m_isolatedWorld.get()); + JSC::JSValue value = result.jsValue(); + if (!value) { + returnType = JSException; + return false; + } + + JSC::ExecState* exec = m_mainFrame->script()->globalObject(m_isolatedWorld.get())->globalExec(); + JSGlobalContextRef context = toGlobalRef(exec); + + JSType type = JSValueGetType(context, toRef(exec, value)); + + switch (type) { + case kJSTypeNull: + returnType = JSNull; + break; + case kJSTypeBoolean: + returnType = JSBoolean; + break; + case kJSTypeNumber: + returnType = JSNumber; + break; + case kJSTypeString: + returnType = JSString; + break; + case kJSTypeObject: + returnType = JSObject; + break; + case kJSTypeUndefined: + default: + returnType = JSUndefined; + break; + } + + if (returnType == JSBoolean || returnType == JSNumber || returnType == JSString || returnType == JSObject) { + String str = result.toString(exec); + returnValue = WebString(str.impl()); + } + + return true; +} + +void WebPagePrivate::stopCurrentLoad() +{ + // This function should contain all common code triggered by WebPage::load + // (which stops any load in progress before starting the new load) and + // WebPage::stoploading (the entry point for the client to stop the load + // explicitly). If it should only be done while stopping the load + // explicitly, it goes in WebPage::stopLoading, not here. + m_mainFrame->loader()->stopAllLoaders(); + + // Cancel any deferred script that hasn't been processed yet. + FrameLoaderClientBlackBerry* frameLoaderClient = static_cast<FrameLoaderClientBlackBerry*>(m_mainFrame->loader()->client()); + frameLoaderClient->setDeferredManualScript(KURL()); +} + +static void closeURLRecursively(Frame* frame) +{ + // Do not create more frame please. + FrameLoaderClientBlackBerry* frameLoaderClient = static_cast<FrameLoaderClientBlackBerry*>(frame->loader()->client()); + frameLoaderClient->suppressChildFrameCreation(); + + frame->loader()->closeURL(); + + Vector<RefPtr<Frame>, 10> childFrames; + + for (RefPtr<Frame> childFrame = frame->tree()->firstChild(); childFrame; childFrame = childFrame->tree()->nextSibling()) + childFrames.append(childFrame); + + unsigned size = childFrames.size(); + for (unsigned i = 0; i < size; i++) + closeURLRecursively(childFrames[i].get()); +} + +void WebPagePrivate::prepareToDestroy() +{ + // Before the client starts tearing itself down, dispatch the unload event + // so it can take effect while all the client's state (e.g. scroll position) + // is still present. + closeURLRecursively(m_mainFrame); +} + +void WebPagePrivate::setLoadState(LoadState state) +{ + if (m_loadState == state) + return; + + bool isFirstLoad = m_loadState == None; + + // See RIM Bug #1068. + if (state == Finished && m_mainFrame && m_mainFrame->document()) + m_mainFrame->document()->updateStyleIfNeeded(); + + m_loadState = state; + +#if DEBUG_WEBPAGE_LOAD + Platform::log(Platform::LogLevelInfo, "WebPagePrivate::setLoadState %d", state); +#endif + + switch (m_loadState) { + case Provisional: + if (isFirstLoad) { + // Paints the visible backingstore as white to prevent initial checkerboard on + // the first blit. + if (m_backingStore->d->renderVisibleContents() && !m_backingStore->d->isSuspended() && !m_backingStore->d->shouldDirectRenderingToWindow()) + m_backingStore->d->blitVisibleContents(); + } + break; + case Committed: + { + unscheduleZoomAboutPoint(); + +#if ENABLE(SKIA_GPU_CANVAS) + if (m_page->settings()->canvasUsesAcceleratedDrawing()) { + // Free GPU resources as we're on a new page. + // This will help us to free memory pressure. + Platform::Graphics::makeSharedResourceContextCurrent(Platform::Graphics::GLES2); + GrContext* grContext = Platform::Graphics::getGrContext(); + grContext->freeGpuResources(); + } +#endif + +#if USE(ACCELERATED_COMPOSITING) + // FIXME: compositor may only be touched on the compositing thread. + // However, it's created/destroyed by a sync command so this is harmless. + if (m_compositor) { + m_compositor->setLayoutRectForCompositing(IntRect()); + m_compositor->setContentsSizeForCompositing(IntSize()); + } +#endif + m_previousContentsSize = IntSize(); + m_backingStore->d->resetRenderQueue(); + m_backingStore->d->resetTiles(true /* resetBackground */); + m_backingStore->d->setScrollingOrZooming(false, false /* shouldBlit */); + m_userPerformedManualZoom = false; + m_userPerformedManualScroll = false; + m_shouldUseFixedDesktopMode = false; + if (m_resetVirtualViewportOnCommitted) { // For DRT. + m_virtualViewportWidth = 0; + m_virtualViewportHeight = 0; + } + if (m_webSettings->viewportWidth() > 0) { + m_virtualViewportWidth = m_webSettings->viewportWidth(); + m_virtualViewportHeight = m_defaultLayoutSize.height(); + } + // Check if we have already process the meta viewport tag, this only happens on history navigation + if (!m_didRestoreFromPageCache) { + m_viewportArguments = ViewportArguments(); + m_userScalable = m_webSettings->isUserScalable(); + resetScales(); + } else { + IntSize virtualViewport = recomputeVirtualViewportFromViewportArguments(); + m_webPage->setVirtualViewportSize(virtualViewport.width(), virtualViewport.height()); + } + +#if ENABLE(EVENT_MODE_METATAGS) + didReceiveCursorEventMode(ProcessedCursorEvents); + didReceiveTouchEventMode(ProcessedTouchEvents); +#endif + + // If it's a outmost SVG document, we use FixedDesktop mode, otherwise + // we default to Mobile mode. For example, using FixedDesktop mode to + // render http://www.croczilla.com/bits_and_pieces/svg/samples/tiger/tiger.svg + // is user-experience friendly. + if (m_page->mainFrame()->document()->isSVGDocument()) { + setShouldUseFixedDesktopMode(true); + setViewMode(FixedDesktop); + } else + setViewMode(Mobile); + + // Reset block zoom and reflow. + resetBlockZoom(); +#if ENABLE(VIEWPORT_REFLOW) + toggleTextReflowIfEnabledForBlockZoomOnly(); +#endif + + // Set the scroll to origin here and notify the client since we'll be + // zooming below without any real contents yet thus the contents size + // we report to the client could make our current scroll position invalid. + setScrollPosition(IntPoint::zero()); + notifyTransformedScrollChanged(); + + // Paints the visible backingstore as white. Note it is important we do + // this strictly after re-setting the scroll position to origin and resetting + // the scales otherwise the visible contents calculation is wrong and we + // can end up blitting artifacts instead. See: RIM Bug #401. + if (m_backingStore->d->renderVisibleContents() && !m_backingStore->d->isSuspended() && !m_backingStore->d->shouldDirectRenderingToWindow()) + m_backingStore->d->blitVisibleContents(); + + zoomToInitialScaleOnLoad(); + + // Update cursor status. + updateCursor(); + +#if USE(ACCELERATED_COMPOSITING) + // Don't render compositing contents from previous page. + resetCompositingSurface(); +#endif + break; + } + case Finished: + case Failed: + // Notify client of the initial zoom change. + m_client->zoomChanged(m_webPage->isMinZoomed(), m_webPage->isMaxZoomed(), !shouldZoomOnEscape(), currentScale()); + m_backingStore->d->updateTiles(true /* updateVisible */, false /* immediate */); + break; + default: + break; + } +} + +double WebPagePrivate::clampedScale(double scale) const +{ + if (scale < minimumScale()) + return minimumScale(); + if (scale > maximumScale()) + return maximumScale(); + return scale; +} + +bool WebPagePrivate::shouldZoomAboutPoint(double scale, const FloatPoint&, bool enforceScaleClamping, double* clampedScale) +{ + if (!m_mainFrame->view()) + return false; + + if (enforceScaleClamping) + scale = this->clampedScale(scale); + + ASSERT(clampedScale); + *clampedScale = scale; + + if (currentScale() == scale) { + // Make sure backingstore updates resume from pinch zoom in the case where the final zoom level doesn't change. + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::None); + m_client->zoomChanged(m_webPage->isMinZoomed(), m_webPage->isMaxZoomed(), !shouldZoomOnEscape(), currentScale()); + return false; + } + + return true; +} + +bool WebPagePrivate::zoomAboutPoint(double unclampedScale, const FloatPoint& anchor, bool enforceScaleClamping, bool forceRendering, bool isRestoringZoomLevel) +{ + if (!isRestoringZoomLevel) { + // Clear any existing block zoom. (If we are restoring a saved zoom level on page load, + // there is guaranteed to be no existing block zoom and we don't want to clear m_shouldReflowBlock.) + resetBlockZoom(); + } + + // The reflow and block zoom stuff here needs to happen regardless of + // whether we shouldZoomAboutPoint. +#if ENABLE(VIEWPORT_REFLOW) + toggleTextReflowIfEnabledForBlockZoomOnly(m_shouldReflowBlock); + if (m_page->settings()->isTextReflowEnabled() && m_mainFrame->view()) + setNeedsLayout(); +#endif + + double scale; + if (!shouldZoomAboutPoint(unclampedScale, anchor, enforceScaleClamping, &scale)) { + if (m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabled) { + m_currentPinchZoomNode = 0; + m_anchorInNodeRectRatio = FloatPoint(-1, -1); + } + return false; + } + TransformationMatrix zoom; + zoom.scale(scale); + +#if DEBUG_WEBPAGE_LOAD + if (loadState() < Finished) + Platform::log(Platform::LogLevelInfo, "WebPagePrivate::zoomAboutPoint scale %f anchor (%f, %f)", scale, anchor.x(), anchor.y()); +#endif + + // Our current scroll position in float. + FloatPoint scrollPosition = this->scrollPosition(); + + // Anchor offset from scroll position in float. + FloatPoint anchorOffset(anchor.x() - scrollPosition.x(), anchor.y() - scrollPosition.y()); + + // The horizontal scaling factor and vertical scaling factor should be equal + // to preserve aspect ratio of content. + ASSERT(m_transformationMatrix->m11() == m_transformationMatrix->m22()); + + // Need to invert the previous transform to anchor the viewport. + double inverseScale = scale / m_transformationMatrix->m11(); + + // Actual zoom. + *m_transformationMatrix = zoom; + + // Suspend all screen updates to the backingstore. + m_backingStore->d->suspendScreenAndBackingStoreUpdates(); + + updateViewportSize(); + + IntPoint newScrollPosition(IntPoint(max(0, static_cast<int>(roundf(anchor.x() - anchorOffset.x() / inverseScale))), + max(0, static_cast<int>(roundf(anchor.y() - anchorOffset.y() / inverseScale))))); + + if (m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabled) { + // This is a hack for email which has reflow always turned on. + m_mainFrame->view()->setNeedsLayout(); + requestLayoutIfNeeded(); + if (m_currentPinchZoomNode) + newScrollPosition = calculateReflowedScrollPosition(anchorOffset, scale == minimumScale() ? 1 : inverseScale); + m_currentPinchZoomNode = 0; + m_anchorInNodeRectRatio = FloatPoint(-1, -1); + } + + setScrollPosition(newScrollPosition); + + notifyTransformChanged(); + + bool isLoading = this->isLoading(); + + // We need to invalidate all tiles both visible and non-visible if we're loading. + m_backingStore->d->updateTiles(isLoading /* updateVisible */, false /* immediate */); + + m_client->resetBitmapZoomScale(m_transformationMatrix->m11()); + + bool shouldRender = !isLoading || m_userPerformedManualZoom || forceRendering; + bool shouldClearVisibleZoom = isLoading && shouldRender; + + if (shouldClearVisibleZoom) { + // If we are loading and rendering then we need to clear the render queue's + // visible zoom jobs as they will be irrelevant with the render below. + m_backingStore->d->clearVisibleZoom(); + } + + // Clear window to make sure there are no artifacts. + if (shouldRender) { + m_backingStore->d->clearWindow(); + // Resume all screen updates to the backingstore and render+blit visible contents to screen. + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::RenderAndBlit); + } else { + // Resume all screen updates to the backingstore but do not blit to the screen because we not rendering. + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::None); + } + + m_client->zoomChanged(m_webPage->isMinZoomed(), m_webPage->isMaxZoomed(), !shouldZoomOnEscape(), currentScale()); + + return true; +} + +IntPoint WebPagePrivate::calculateReflowedScrollPosition(const FloatPoint& anchorOffset, double inverseScale) +{ + // Should only be invoked when text reflow is enabled. + ASSERT(m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabled); + + int offsetY = 0; + int offsetX = 0; + + IntRect nodeRect = rectForNode(m_currentPinchZoomNode.get()); + + if (m_currentPinchZoomNode->renderer() && m_anchorInNodeRectRatio.y() >= 0) { + offsetY = nodeRect.height() * m_anchorInNodeRectRatio.y(); + if (m_currentPinchZoomNode->renderer()->isImage() && m_anchorInNodeRectRatio.x() > 0) + offsetX = nodeRect.width() * m_anchorInNodeRectRatio.x() - anchorOffset.x() / inverseScale; + } + + IntRect reflowedRect = adjustRectOffsetForFrameOffset(nodeRect, m_currentPinchZoomNode.get()); + + return IntPoint(max(0, static_cast<int>(roundf(reflowedRect.x() + offsetX))), + max(0, static_cast<int>(roundf(reflowedRect.y() + offsetY - anchorOffset.y() / inverseScale)))); +} + +bool WebPagePrivate::scheduleZoomAboutPoint(double unclampedScale, const FloatPoint& anchor, bool enforceScaleClamping, bool forceRendering) +{ + double scale; + if (!shouldZoomAboutPoint(unclampedScale, anchor, enforceScaleClamping, &scale)) { + // We could be back to the right zoom level before the timer has + // timed out, because of wiggling back and forth. Stop the timer. + unscheduleZoomAboutPoint(); + return false; + } + + // For some reason, the bitmap zoom wants an anchor in backingstore coordinates! + // this is different from zoomAboutPoint, which wants content coordinates. + // See RIM Bug #641. + + FloatPoint transformedAnchor = mapToTransformedFloatPoint(anchor); + FloatPoint transformedScrollPosition = mapToTransformedFloatPoint(scrollPosition()); + + // Prohibit backingstore from updating the window overtop of the bitmap. + m_backingStore->d->suspendScreenAndBackingStoreUpdates(); + + // Need to invert the previous transform to anchor the viewport. + double zoomFraction = scale / transformationMatrix()->m11(); + + // Anchor offset from scroll position in float. + FloatPoint anchorOffset(transformedAnchor.x() - transformedScrollPosition.x(), + transformedAnchor.y() - transformedScrollPosition.y()); + + IntPoint srcPoint( + static_cast<int>(roundf(transformedAnchor.x() - anchorOffset.x() / zoomFraction)), + static_cast<int>(roundf(transformedAnchor.y() - anchorOffset.y() / zoomFraction))); + + const IntRect viewportRect = IntRect(IntPoint::zero(), transformedViewportSize()); + const IntRect dstRect = viewportRect; + + // This is the rect to pass as the actual source rect in the backingstore + // for the transform given by zoom. + IntRect srcRect(srcPoint.x(), + srcPoint.y(), + viewportRect.width() / zoomFraction, + viewportRect.height() / zoomFraction); + m_backingStore->d->blitContents(dstRect, srcRect); + + m_delayedZoomArguments.scale = scale; + m_delayedZoomArguments.anchor = anchor; + m_delayedZoomArguments.enforceScaleClamping = enforceScaleClamping; + m_delayedZoomArguments.forceRendering = forceRendering; + m_delayedZoomTimer->startOneShot(delayedZoomInterval); + + return true; +} + +void WebPagePrivate::unscheduleZoomAboutPoint() +{ + if (m_delayedZoomTimer->isActive()) + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::None); + + m_delayedZoomTimer->stop(); +} + +void WebPagePrivate::zoomAboutPointTimerFired(Timer<WebPagePrivate>*) +{ + zoomAboutPoint(m_delayedZoomArguments.scale, m_delayedZoomArguments.anchor, m_delayedZoomArguments.enforceScaleClamping, m_delayedZoomArguments.forceRendering); +} + +void WebPagePrivate::setNeedsLayout() +{ + FrameView* view = m_mainFrame->view(); + ASSERT(view); + view->setNeedsLayout(); +} + +void WebPagePrivate::requestLayoutIfNeeded() const +{ + FrameView* view = m_mainFrame->view(); + ASSERT(view); + view->updateLayoutAndStyleIfNeededRecursive(); + ASSERT(!view->needsLayout()); +} + +IntPoint WebPagePrivate::scrollPosition() const +{ + return m_backingStoreClient->scrollPosition(); +} + +IntPoint WebPagePrivate::maximumScrollPosition() const +{ + return m_backingStoreClient->maximumScrollPosition(); +} + +void WebPagePrivate::setScrollPosition(const IntPoint& pos) +{ + m_backingStoreClient->setScrollPosition(pos); +} + +bool WebPagePrivate::shouldSendResizeEvent() +{ + if (!m_mainFrame->document()) + return false; + + // PR#96865 : Provide an option to always send resize events, regardless of the loading + // status. The scenario for this are Sapphire applications which tend to + // maintain an open GET request to the server. This open GET results in + // webkit thinking that content is still arriving when at the application + // level it is considered fully loaded. + // + // NOTE: Care must be exercised in the use of this option, as it bypasses + // the sanity provided in 'isLoadingInAPISense()' below. + // + static const bool unrestrictedResizeEvents = Platform::Settings::get()->unrestrictedResizeEvents(); + if (unrestrictedResizeEvents) + return true; + + // Don't send the resize event if the document is loading. Some pages automatically reload + // when the window is resized; Safari on iPhone often resizes the window while setting up its + // viewport. This obviously can cause problems. + DocumentLoader* documentLoader = m_mainFrame->loader()->documentLoader(); + if (documentLoader && documentLoader->isLoadingInAPISense()) + return false; + + return true; +} + +void WebPagePrivate::willDeferLoading() +{ + m_client->willDeferLoading(); +} + +void WebPagePrivate::didResumeLoading() +{ + m_client->didResumeLoading(); +} + +bool WebPage::scrollBy(const Platform::IntSize& delta, bool scrollMainFrame) +{ + d->m_backingStoreClient->setIsClientGeneratedScroll(true); + bool b = d->scrollBy(delta.width(), delta.height(), scrollMainFrame); + d->m_backingStoreClient->setIsClientGeneratedScroll(false); + return b; +} + +bool WebPagePrivate::scrollBy(int deltaX, int deltaY, bool scrollMainFrame) +{ + IntSize delta(deltaX, deltaY); + if (!scrollMainFrame) { + // We need to work around the fact that ::map{To,From}Transformed do not + // work well with negative values, like a negative width or height of an IntSize. + IntSize copiedDelta(IntSize(abs(delta.width()), abs(delta.height()))); + IntSize untransformedCopiedDelta = mapFromTransformed(copiedDelta); + delta = IntSize( + delta.width() < 0 ? -untransformedCopiedDelta.width() : untransformedCopiedDelta.width(), + delta.height() < 0 ? -untransformedCopiedDelta.height(): untransformedCopiedDelta.height()); + + if (m_inRegionScrollStartingNode) { + if (scrollNodeRecursively(m_inRegionScrollStartingNode.get(), delta)) { + m_selectionHandler->selectionPositionChanged(); + // FIXME: We have code in place to handle scrolling and clipping tap highlight + // on in-region scrolling. As soon as it is fast enough (i.e. we have it backed by + // a backing store), we can reliably make use of it in the real world. + // m_touchEventHandler->drawTapHighlight(); + return true; + } + } + + return false; + } + + setScrollPosition(scrollPosition() + delta); + return true; +} + +void WebPage::notifyInRegionScrollStatusChanged(bool status) +{ + d->notifyInRegionScrollStatusChanged(status); +} + +void WebPagePrivate::notifyInRegionScrollStatusChanged(bool status) +{ + if (!status && m_inRegionScrollStartingNode) { + enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling(m_inRegionScrollStartingNode.get()); + m_inRegionScrollStartingNode = 0; + } +} + +void WebPagePrivate::enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling(Node* scrolledNode) +{ + ASSERT(scrolledNode); + if (scrolledNode->isDocumentNode()) { + Frame* frame = static_cast<const Document*>(scrolledNode)->frame(); + ASSERT(frame); + if (!frame) + return; + ASSERT(frame != m_mainFrame); + FrameView* view = frame->view(); + if (!view) + return; + + // Steps: + // #1 - Get frame rect in contents coords. + // #2 - Get the clipped scrollview rect in contents coords. + // #3 - Take transform into account for 1 and 2. + // #4 - Subtract 2 from 1, so we know exactly which areas of the frame + // are offscreen, and need async repainting. + FrameView* mainFrameView = m_mainFrame->view(); + ASSERT(mainFrameView); + IntRect frameRect = view->frameRect(); + frameRect = frame->tree()->parent()->view()->contentsToWindow(frameRect); + frameRect = mainFrameView->windowToContents(frameRect); + + IntRect visibleWindowRect = getRecursiveVisibleWindowRect(view); + IntRect visibleContentsRect = mainFrameView->windowToContents(visibleWindowRect); + + IntRect transformedFrameRect = mapToTransformed(frameRect); + IntRect transformedVisibleContentsRect = mapToTransformed(visibleContentsRect); + + Platform::IntRectRegion offscreenRegionOfIframe + = Platform::IntRectRegion::subtractRegions(Platform::IntRect(transformedFrameRect), Platform::IntRect(transformedVisibleContentsRect)); + + if (!offscreenRegionOfIframe.isEmpty()) + m_backingStore->d->m_renderQueue->addToQueue(RenderQueue::RegularRender, offscreenRegionOfIframe.rects()); + } +} + +void WebPagePrivate::setHasInRegionScrollableAreas(bool b) +{ + if (b != m_hasInRegionScrollableAreas) + m_hasInRegionScrollableAreas = b; +} + +IntSize WebPagePrivate::viewportSize() const +{ + return mapFromTransformed(transformedViewportSize()); +} + +IntSize WebPagePrivate::actualVisibleSize() const +{ + return mapFromTransformed(transformedActualVisibleSize()); +} + +bool WebPagePrivate::hasVirtualViewport() const +{ + return m_virtualViewportWidth && m_virtualViewportHeight; +} + +void WebPagePrivate::updateViewportSize(bool setFixedReportedSize, bool sendResizeEvent) +{ + ASSERT(m_mainFrame->view()); + if (setFixedReportedSize) + m_mainFrame->view()->setFixedReportedSize(actualVisibleSize()); + + IntRect frameRect = IntRect(scrollPosition(), viewportSize()); + if (frameRect != m_mainFrame->view()->frameRect()) { + m_mainFrame->view()->setFrameRect(frameRect); + m_mainFrame->view()->adjustViewSize(); + } + + // We're going to need to send a resize event to JavaScript because + // innerWidth and innerHeight depend on fixed reported size. + // This is how we support mobile pages where JavaScript resizes + // the page in order to get around the fixed layout size, e.g. + // google maps when it detects a mobile user agent. + if (sendResizeEvent && shouldSendResizeEvent()) + m_mainFrame->eventHandler()->sendResizeEvent(); + + // When the actual visible size changes, we also + // need to reposition fixed elements. + m_mainFrame->view()->repaintFixedElementsAfterScrolling(); +} + +FloatPoint WebPagePrivate::centerOfVisibleContentsRect() const +{ + // The visible contents rect in float. + FloatRect visibleContentsRect = this->visibleContentsRect(); + + // The center of the visible contents rect in float. + return FloatPoint(visibleContentsRect.x() + visibleContentsRect.width() / 2.0, + visibleContentsRect.y() + visibleContentsRect.height() / 2.0); +} + +IntRect WebPagePrivate::visibleContentsRect() const +{ + return m_backingStoreClient->visibleContentsRect(); +} + +IntSize WebPagePrivate::contentsSize() const +{ + if (!m_mainFrame->view()) + return IntSize(); + + return m_backingStoreClient->contentsSize(); +} + +IntSize WebPagePrivate::absoluteVisibleOverflowSize() const +{ + if (!m_mainFrame->contentRenderer()) + return IntSize(); + + return IntSize(m_mainFrame->contentRenderer()->rightAbsoluteVisibleOverflow(), m_mainFrame->contentRenderer()->bottomAbsoluteVisibleOverflow()); +} + +void WebPagePrivate::contentsSizeChanged(const IntSize& contentsSize) +{ + if (m_previousContentsSize == contentsSize) + return; + + // This should only occur in the middle of layout so we set a flag here and + // handle it at the end of the layout. + m_contentsSizeChanged = true; + +#if DEBUG_WEBPAGE_LOAD + Platform::log(Platform::LogLevelInfo, "WebPagePrivate::contentsSizeChanged %dx%d", contentsSize.width(), contentsSize.height()); +#endif +} + +void WebPagePrivate::layoutFinished() +{ + if (!m_contentsSizeChanged && !m_overflowExceedsContentsSize) + return; + + m_contentsSizeChanged = false; // Toggle to turn off notification again. + m_overflowExceedsContentsSize = false; + + if (contentsSize().isEmpty()) + return; + + // The call to zoomToInitialScaleOnLoad can cause recursive layout when called from + // the middle of a layout, but the recursion is limited by detection code in + // setViewMode() and mitigation code in fixedLayoutSize(). + if (didLayoutExceedMaximumIterations()) { + notifyTransformedContentsSizeChanged(); + return; + } + + // Temporarily save the m_previousContentsSize here before updating it (in + // notifyTransformedContentsSizeChanged()) so we can compare if our contents + // shrunk afterwards. + IntSize previousContentsSize = m_previousContentsSize; + + m_nestedLayoutFinishedCount++; + + if (loadState() == Committed) + zoomToInitialScaleOnLoad(); + else if (loadState() != None) + notifyTransformedContentsSizeChanged(); + + m_nestedLayoutFinishedCount--; + + if (!m_nestedLayoutFinishedCount) { + // When the contents shrinks, there is a risk that we + // will be left at a scroll position that lies outside of the + // contents rect. Since we allow overscrolling and neglect + // to clamp overscroll in order to retain input focus (RIM Bug #414) + // we need to clamp somewhere, and this is where we know the + // contents size has changed. + + if (contentsSize() != previousContentsSize) { + + IntPoint newScrollPosition = scrollPosition(); + + if (contentsSize().height() < previousContentsSize.height()) { + IntPoint scrollPositionWithHeightShrunk = IntPoint(newScrollPosition.x(), maximumScrollPosition().y()); + newScrollPosition = newScrollPosition.shrunkTo(scrollPositionWithHeightShrunk); + } + + if (contentsSize().width() < previousContentsSize.width()) { + IntPoint scrollPositionWithWidthShrunk = IntPoint(maximumScrollPosition().x(), newScrollPosition.y()); + newScrollPosition = newScrollPosition.shrunkTo(scrollPositionWithWidthShrunk); + } + + if (newScrollPosition != scrollPosition()) { + setScrollPosition(newScrollPosition); + notifyTransformedScrollChanged(); + } + } + } +} + +void WebPagePrivate::zoomToInitialScaleOnLoad() +{ +#if DEBUG_WEBPAGE_LOAD + Platform::log(Platform::LogLevelInfo, "WebPagePrivate::zoomToInitialScaleOnLoad"); +#endif + + bool needsLayout = false; + + // If the contents width exceeds the viewport width set to desktop mode. + if (m_shouldUseFixedDesktopMode) + needsLayout = setViewMode(FixedDesktop); + else + needsLayout = setViewMode(Desktop); + + if (needsLayout) { + // This can cause recursive layout... + setNeedsLayout(); + } + + if (contentsSize().isEmpty()) { +#if DEBUG_WEBPAGE_LOAD + Platform::log(Platform::LogLevelInfo, "WebPagePrivate::zoomToInitialScaleOnLoad content is empty!"); +#endif + requestLayoutIfNeeded(); + m_client->resetBitmapZoomScale(currentScale()); + notifyTransformedContentsSizeChanged(); + return; + } + + bool performedZoom = false; + bool shouldZoom = !m_userPerformedManualZoom; + + // If this load should restore view state, don't zoom to initial scale + // but instead let the HistoryItem's saved viewport reign supreme. + if (m_mainFrame && m_mainFrame->loader() && m_mainFrame->loader()->shouldRestoreScrollPositionAndViewState()) + shouldZoom = false; + + if (shouldZoom && loadState() == Committed) { + // Preserve at top and at left position, to avoid scrolling + // to a non top-left position for web page with viewport meta tag + // that specifies an initial-scale that is zoomed in. + FloatPoint anchor = centerOfVisibleContentsRect(); + if (!scrollPosition().x()) + anchor.setX(0); + if (!scrollPosition().y()) + anchor.setY(0); + performedZoom = zoomAboutPoint(initialScale(), anchor); + } + + // zoomAboutPoint above can also toggle setNeedsLayout and cause recursive layout... + requestLayoutIfNeeded(); + + if (!performedZoom) { + // We only notify if we didn't perform zoom, because zoom will notify on + // its own... + m_client->resetBitmapZoomScale(currentScale()); + notifyTransformedContentsSizeChanged(); + } +} + +double WebPagePrivate::zoomToFitScale() const +{ + // We must clamp the contents for this calculation so that we do not allow an + // arbitrarily small zoomToFitScale much like we clamp the fixedLayoutSize() + // so that we do not have arbitrarily large layout size. + // If we have a specified viewport, we may need to be able to zoom out more. + int contentWidth = std::min(contentsSize().width(), std::max(m_virtualViewportWidth, static_cast<int>(defaultMaxLayoutSize().width()))); + + // defaultMaxLayoutSize().width() is a safeguard for excessively large page layouts that + // is too restrictive for image documents. In this case, the document width is sufficient. + Document* doc = m_page->mainFrame()->document(); + if (doc && doc->isImageDocument()) + contentWidth = contentsSize().width(); + + // If we have a virtual viewport and its aspect ratio caused content to layout + // wider than the default layout aspect ratio we need to zoom to fit the content height + // in order to avoid showing a grey area below the web page. + // Without virtual viewport we can never get into this situation. + if (hasVirtualViewport()) { + int contentHeight = std::min(contentsSize().height(), std::max(m_virtualViewportHeight, static_cast<int>(defaultMaxLayoutSize().height()))); + + // Aspect ratio check without division. + if (contentWidth * m_defaultLayoutSize.height() > contentHeight * m_defaultLayoutSize.width()) + return contentHeight > 0 ? static_cast<double>(m_defaultLayoutSize.height()) / contentHeight : 1.0; + } + + return contentWidth > 0.0 ? static_cast<double>(m_actualVisibleWidth) / contentWidth : 1.0; +} + +double WebPagePrivate::initialScale() const +{ + if (m_initialScale > 0.0) + return m_initialScale; + + if (m_webSettings->isZoomToFitOnLoad()) + return zoomToFitScale(); + + return 1.0; +} + +void WebPage::initializeIconDataBase() +{ + IconDatabaseClientBlackBerry::getInstance()->initIconDatabase(d->m_webSettings); +} + +bool WebPage::isUserScalable() const +{ + return d->isUserScalable(); +} + +double WebPage::currentScale() const +{ + return d->currentScale(); +} + +double WebPage::initialScale() const +{ + return d->initialScale(); +} + +double WebPage::zoomToFitScale() const +{ + return d->zoomToFitScale(); +} + +void WebPage::setInitialScale(double initialScale) +{ + d->setInitialScale(initialScale); +} + +double WebPage::minimumScale() const +{ + return d->minimumScale(); +} + +void WebPage::setMinimumScale(double minimumScale) +{ + d->setMinimumScale(minimumScale); +} + +double WebPage::maximumScale() const +{ + return d->maximumScale(); +} + +void WebPage::setMaximumScale(double maximumScale) +{ + d->setMaximumScale(maximumScale); +} + +double WebPagePrivate::maximumScale() const +{ + if (m_maximumScale >= zoomToFitScale() && m_maximumScale >= m_minimumScale) + return m_maximumScale; + + return hasVirtualViewport() ? std::max<double>(zoomToFitScale(), 4.0) : 4.0; +} + +void WebPagePrivate::resetScales() +{ + TransformationMatrix identity; + *m_transformationMatrix = identity; + m_initialScale = m_webSettings->initialScale() > 0 ? m_webSettings->initialScale() : -1.0; + m_minimumScale = -1.0; + m_maximumScale = -1.0; + + // We have to let WebCore know about updated framerect now that we've + // reset our scales. See: RIM Bug #401. + updateViewportSize(); +} + +IntPoint WebPagePrivate::transformedScrollPosition() const +{ + return m_backingStoreClient->transformedScrollPosition(); +} + +IntPoint WebPagePrivate::transformedMaximumScrollPosition() const +{ + return m_backingStoreClient->transformedMaximumScrollPosition(); +} + +IntSize WebPagePrivate::transformedActualVisibleSize() const +{ + return IntSize(m_actualVisibleWidth, m_actualVisibleHeight); +} + +IntSize WebPagePrivate::transformedViewportSize() const +{ + return Platform::Graphics::Screen::size(); +} + +IntRect WebPagePrivate::transformedVisibleContentsRect() const +{ + // Usually this would be mapToTransformed(visibleContentsRect()), but + // that results in rounding errors because we already set the WebCore + // viewport size from our original transformedViewportSize(). + // Instead, we only transform the scroll position and take the + // viewport size as it is, which ensures that e.g. blitting operations + // always cover the whole widget/screen. + return IntRect(transformedScrollPosition(), transformedViewportSize()); +} + +IntSize WebPagePrivate::transformedContentsSize() const +{ + // mapToTransformed() functions use this method to crop their results, + // so we can't make use of them here. While we want rounding inside page + // boundaries to extend rectangles and round points, we need to crop the + // contents size to the floored values so that we don't try to display + // or report points that are not fully covered by the actual float-point + // contents rectangle. + const IntSize untransformedContentsSize = contentsSize(); + const FloatPoint transformedBottomRight = m_transformationMatrix->mapPoint( + FloatPoint(untransformedContentsSize.width(), untransformedContentsSize.height())); + return IntSize(floorf(transformedBottomRight.x()), floorf(transformedBottomRight.y())); +} + +IntPoint WebPagePrivate::mapFromContentsToViewport(const IntPoint& point) const +{ + return m_backingStoreClient->mapFromContentsToViewport(point); +} + +IntPoint WebPagePrivate::mapFromViewportToContents(const IntPoint& point) const +{ + return m_backingStoreClient->mapFromViewportToContents(point); +} + +IntRect WebPagePrivate::mapFromContentsToViewport(const IntRect& rect) const +{ + return m_backingStoreClient->mapFromContentsToViewport(rect); +} + +IntRect WebPagePrivate::mapFromViewportToContents(const IntRect& rect) const +{ + return m_backingStoreClient->mapFromViewportToContents(rect); +} + +IntPoint WebPagePrivate::mapFromTransformedContentsToTransformedViewport(const IntPoint& point) const +{ + return m_backingStoreClient->mapFromTransformedContentsToTransformedViewport(point); +} + +IntPoint WebPagePrivate::mapFromTransformedViewportToTransformedContents(const IntPoint& point) const +{ + return m_backingStoreClient->mapFromTransformedViewportToTransformedContents(point); +} + +IntRect WebPagePrivate::mapFromTransformedContentsToTransformedViewport(const IntRect& rect) const +{ + return m_backingStoreClient->mapFromTransformedContentsToTransformedViewport(rect); +} + +IntRect WebPagePrivate::mapFromTransformedViewportToTransformedContents(const IntRect& rect) const +{ + return m_backingStoreClient->mapFromTransformedViewportToTransformedContents(rect); +} + +// NOTE: PIXEL ROUNDING! +// Accurate back-and-forth rounding is not possible with information loss +// by integer points and sizes, so we always expand the resulting mapped +// float rectangles to the nearest integer. For points, we always use +// floor-rounding in mapToTransformed() so that we don't have to crop to +// the (floor'd) transformed contents size. +static inline IntPoint roundTransformedPoint(const FloatPoint &point) +{ + // Maps by rounding half towards zero. + return IntPoint(static_cast<int>(floorf(point.x())), static_cast<int>(floorf(point.y()))); +} + +static inline IntPoint roundUntransformedPoint(const FloatPoint &point) +{ + // Maps by rounding half away from zero. + return IntPoint(static_cast<int>(ceilf(point.x())), static_cast<int>(ceilf(point.y()))); +} + +IntPoint WebPagePrivate::mapToTransformed(const IntPoint& point) const +{ + return roundTransformedPoint(m_transformationMatrix->mapPoint(FloatPoint(point))); +} + +FloatPoint WebPagePrivate::mapToTransformedFloatPoint(const FloatPoint& point) const +{ + return m_transformationMatrix->mapPoint(point); +} + +IntPoint WebPagePrivate::mapFromTransformed(const IntPoint& point) const +{ + return roundUntransformedPoint(m_transformationMatrix->inverse().mapPoint(FloatPoint(point))); +} + +FloatPoint WebPagePrivate::mapFromTransformedFloatPoint(const FloatPoint& point) const +{ + return m_transformationMatrix->inverse().mapPoint(point); +} + +FloatRect WebPagePrivate::mapFromTransformedFloatRect(const FloatRect& rect) const +{ + return m_transformationMatrix->inverse().mapRect(rect); +} + +IntSize WebPagePrivate::mapToTransformed(const IntSize& size) const +{ + return mapToTransformed(IntRect(IntPoint::zero(), size)).size(); +} + +IntSize WebPagePrivate::mapFromTransformed(const IntSize& size) const +{ + return mapFromTransformed(IntRect(IntPoint::zero(), size)).size(); +} + +IntRect WebPagePrivate::mapToTransformed(const IntRect& rect) const +{ + return enclosingIntRect(m_transformationMatrix->mapRect(FloatRect(rect))); +} + +// Use this in conjunction with mapToTransformed(IntRect), in most cases. +void WebPagePrivate::clipToTransformedContentsRect(IntRect& rect) const +{ + rect.intersect(IntRect(IntPoint::zero(), transformedContentsSize())); +} + +IntRect WebPagePrivate::mapFromTransformed(const IntRect& rect) const +{ + return enclosingIntRect(m_transformationMatrix->inverse().mapRect(FloatRect(rect))); +} + +bool WebPagePrivate::transformedPointEqualsUntransformedPoint(const IntPoint& transformedPoint, const IntPoint& untransformedPoint) +{ + // Scaling down is always more accurate than scaling up. + if (m_transformationMatrix->a() > 1.0) + return transformedPoint == mapToTransformed(untransformedPoint); + + return mapFromTransformed(transformedPoint) == untransformedPoint; +} + +void WebPagePrivate::notifyTransformChanged() +{ + notifyTransformedContentsSizeChanged(); + notifyTransformedScrollChanged(); + + m_backingStore->d->transformChanged(); +} + +void WebPagePrivate::notifyTransformedContentsSizeChanged() +{ + // We mark here as the last reported content size we sent to the client. + m_previousContentsSize = contentsSize(); + + const IntSize size = transformedContentsSize(); + m_backingStore->d->contentsSizeChanged(size); + m_client->contentsSizeChanged(size); + m_selectionHandler->selectionPositionChanged(); +} + +void WebPagePrivate::notifyTransformedScrollChanged() +{ + const IntPoint pos = transformedScrollPosition(); + m_backingStore->d->scrollChanged(pos); + m_client->scrollChanged(pos); +} + +bool WebPagePrivate::setViewMode(ViewMode mode) +{ + if (!m_mainFrame->view()) + return false; + + m_viewMode = mode; + + // If we're in the middle of a nested layout with a recursion count above + // some maximum threshold, then our algorithm for finding the minimum content + // width of a given page has become dependent on the visible width. + // + // We need to find some method to ensure that we don't experience excessive + // and even infinite recursion. This can even happen with valid html. The + // former can happen when we run into inline text with few candidates for line + // break. The latter can happen for instance if the page has a negative margin + // set against the right border. Note: this is valid by spec and can lead to + // a situation where there is no value for which the content width will ensure + // no horizontal scrollbar. + // Example: LayoutTests/css1/box_properties/margin.html + // + // In order to address such situations when we detect a recursion above some + // maximum threshold we snap our fixed layout size to a defined quantum increment. + // Eventually, either the content width will be satisfied to ensure no horizontal + // scrollbar or this increment will run into the maximum layout size and the + // recursion will necessarily end. + bool snapToIncrement = didLayoutExceedMaximumIterations(); + + IntSize currentSize = m_mainFrame->view()->fixedLayoutSize(); + IntSize newSize = fixedLayoutSize(snapToIncrement); + if (currentSize == newSize) + return false; + + // FIXME: Temp solution. We'll get back to this. + if (m_nestedLayoutFinishedCount) { + double widthChange = fabs(double(newSize.width() - currentSize.width()) / currentSize.width()); + double heightChange = fabs(double(newSize.height() - currentSize.height()) / currentSize.height()); + if (widthChange < 0.05 && heightChange < 0.05) + return false; + } + + m_mainFrame->view()->setUseFixedLayout(useFixedLayout()); + m_mainFrame->view()->setFixedLayoutSize(newSize); + return true; // Needs re-layout! +} + +void WebPagePrivate::setCursor(PlatformCursorHandle handle) +{ + if (m_currentCursor.type() != handle.type()) { + m_currentCursor = handle; + m_client->cursorChanged(handle.type(), handle.url().c_str(), handle.hotspot().x(), handle.hotspot().y()); + } +} + +Platform::NetworkStreamFactory* WebPagePrivate::networkStreamFactory() +{ + return m_client->networkStreamFactory(); +} + +Platform::Graphics::Window* WebPagePrivate::platformWindow() const +{ + return m_client->window(); +} + +void WebPagePrivate::setPreventsScreenDimming(bool keepAwake) +{ + if (keepAwake) { + if (!m_preventIdleDimmingCount) + m_client->setPreventsScreenIdleDimming(true); + m_preventIdleDimmingCount++; + } else if (m_preventIdleDimmingCount > 0) { + m_preventIdleDimmingCount--; + if (!m_preventIdleDimmingCount) + m_client->setPreventsScreenIdleDimming(false); + } else + ASSERT_NOT_REACHED(); // SetPreventsScreenIdleDimming(false) called too many times. +} + +void WebPagePrivate::showVirtualKeyboard(bool showKeyboard) +{ + m_client->showVirtualKeyboard(showKeyboard); +} + +void WebPagePrivate::ensureContentVisible(bool centerInView) +{ + m_inputHandler->ensureFocusElementVisible(centerInView); +} + +void WebPagePrivate::zoomToContentRect(const IntRect& rect) +{ + // Don't scale if the user is not supposed to scale. + if (!isUserScalable()) + return; + + FloatPoint anchor = FloatPoint(rect.width() / 2.0 + rect.x(), rect.height() / 2.0 + rect.y()); + IntSize viewSize = viewportSize(); + + // Calculate the scale required to scale that dimension to fit. + double scaleH = (double)viewSize.width() / (double)rect.width(); + double scaleV = (double)viewSize.height() / (double)rect.height(); + + // Choose the smaller scale factor so that all of the content is visible. + zoomAboutPoint(min(scaleH, scaleV), anchor); +} + +void WebPagePrivate::registerPlugin(PluginView* plugin, bool shouldRegister) +{ + if (shouldRegister) + m_pluginViews.add(plugin); + else + m_pluginViews.remove(plugin); +} + +#define FOR_EACH_PLUGINVIEW(pluginViews) \ + HashSet<PluginView*>::const_iterator it = pluginViews.begin(); \ + HashSet<PluginView*>::const_iterator last = pluginViews.end(); \ + for (; it != last; ++it) + +void WebPagePrivate::notifyPageOnLoad() +{ + FOR_EACH_PLUGINVIEW(m_pluginViews) + (*it)->handleOnLoadEvent(); +} + +bool WebPagePrivate::shouldPluginEnterFullScreen(PluginView* plugin, const char* windowUniquePrefix) +{ + return m_client->shouldPluginEnterFullScreen(); +} + +void WebPagePrivate::didPluginEnterFullScreen(PluginView* plugin, const char* windowUniquePrefix) +{ + m_fullScreenPluginView = plugin; + m_client->didPluginEnterFullScreen(); + Platform::Graphics::Window::setTransparencyDiscardFilter(windowUniquePrefix); + m_client->window()->setSensitivityFullscreenOverride(true); +} + +void WebPagePrivate::didPluginExitFullScreen(PluginView* plugin, const char* windowUniquePrefix) +{ + m_fullScreenPluginView = 0; + m_client->didPluginExitFullScreen(); + Platform::Graphics::Window::setTransparencyDiscardFilter(0); + m_client->window()->setSensitivityFullscreenOverride(false); +} + +void WebPagePrivate::onPluginStartBackgroundPlay(PluginView* plugin, const char* windowUniquePrefix) +{ + m_client->onPluginStartBackgroundPlay(); +} + +void WebPagePrivate::onPluginStopBackgroundPlay(PluginView* plugin, const char* windowUniquePrefix) +{ + m_client->onPluginStopBackgroundPlay(); +} + +bool WebPagePrivate::lockOrientation(bool landscape) +{ + return m_client->lockOrientation(landscape); +} + +void WebPagePrivate::unlockOrientation() +{ + return m_client->unlockOrientation(); +} + +int WebPagePrivate::orientation() const +{ +#if ENABLE(ORIENTATION_EVENTS) + return m_mainFrame->orientation(); +#else +#error ORIENTATION_EVENTS must be defined. +// Or a copy of the orientation value will have to be stored in these objects. +#endif +} + +double WebPagePrivate::currentZoomFactor() const +{ + return currentScale(); +} + +int WebPagePrivate::showAlertDialog(WebPageClient::AlertType atype) +{ + return m_client->showAlertDialog(atype); +} + +bool WebPagePrivate::isActive() const +{ + return m_client->isActive(); +} + +bool WebPagePrivate::useFixedLayout() const +{ + return true; +} + +ActiveNodeContext WebPagePrivate::activeNodeContext(TargetDetectionStrategy strategy) +{ + ActiveNodeContext context; + + RefPtr<Node> node = contextNode(strategy); + m_currentContextNode = node; + if (!m_currentContextNode) + return context; + + requestLayoutIfNeeded(); + + bool nodeAllowSelectionOverride = false; + if (Node* linkNode = node->enclosingLinkEventParentOrSelf()) { + KURL href; + if (linkNode->isLink() && linkNode->hasAttributes()) { + if (Attribute* attribute = linkNode->attributes()->getAttributeItem(HTMLNames::hrefAttr)) + href = linkNode->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(attribute->value())); + } + + String pattern = findPatternStringForUrl(href); + if (!pattern.isEmpty()) + context.setPattern(pattern); + + if (!href.string().isEmpty()) { + context.setUrl(href.string()); + + // Links are non-selectable by default, but selection should be allowed + // providing the page is selectable, use the parent to determine it. + if (linkNode->parentNode() && linkNode->parentNode()->canStartSelection()) + nodeAllowSelectionOverride = true; + } + } + + if (!nodeAllowSelectionOverride && !node->canStartSelection()) + context.resetFlag(ActiveNodeContext::IsSelectable); + + if (node->isHTMLElement()) { + HTMLImageElement* imageElement = 0; + if (node->hasTagName(HTMLNames::imgTag)) + imageElement = static_cast<HTMLImageElement*>(node.get()); + else if (node->hasTagName(HTMLNames::areaTag)) + imageElement = static_cast<HTMLAreaElement*>(node.get())->imageElement(); + if (imageElement && imageElement->renderer()) { + // FIXME: At the mean time, we only show "Save Image" when the image data is available. + if (CachedResource* cachedResource = imageElement->cachedImage()) { + if (cachedResource->isLoaded() && cachedResource->data()) { + String url = stripLeadingAndTrailingHTMLSpaces(imageElement->getAttribute(HTMLNames::srcAttr).string()); + context.setImageSrc(node->document()->completeURL(url).string()); + } + } + String alt = imageElement->altText(); + if (!alt.isNull()) + context.setImageAlt(alt); + } + } + + if (node->isTextNode()) { + Text* curText = static_cast<Text*>(node.get()); + if (!curText->wholeText().isEmpty()) + context.setText(curText->wholeText()); + } + + if (node->isElementNode()) { + Element* element = static_cast<Element*>(node->shadowAncestorNode()); + if (DOMSupport::isTextBasedContentEditableElement(element)) { + context.setFlag(ActiveNodeContext::IsInput); + if (element->hasTagName(HTMLNames::inputTag)) + context.setFlag(ActiveNodeContext::IsSingleLine); + if (DOMSupport::isPasswordElement(element)) + context.setFlag(ActiveNodeContext::IsPassword); + + String elementText(DOMSupport::inputElementText(element)); + if (!elementText.stripWhiteSpace().isEmpty()) + context.setText(elementText); + } + } + + if (node->isFocusable()) + context.setFlag(ActiveNodeContext::IsFocusable); + + return context; +} + +void WebPagePrivate::updateCursor() +{ + int buttonMask = 0; + if (m_lastMouseEvent.button() == LeftButton) + buttonMask = Platform::MouseEvent::ScreenLeftMouseButton; + else if (m_lastMouseEvent.button() == MiddleButton) + buttonMask = Platform::MouseEvent::ScreenMiddleMouseButton; + else if (m_lastMouseEvent.button() == RightButton) + buttonMask = Platform::MouseEvent::ScreenRightMouseButton; + + Platform::MouseEvent event(buttonMask, buttonMask, mapToTransformed(m_lastMouseEvent.pos()), mapToTransformed(m_lastMouseEvent.globalPos()), 0, 0); + m_webPage->mouseEvent(event); +} + +IntSize WebPagePrivate::fixedLayoutSize(bool snapToIncrement) const +{ + if (hasVirtualViewport()) + return IntSize(m_virtualViewportWidth, m_virtualViewportHeight); + + const int defaultLayoutWidth = m_defaultLayoutSize.width(); + const int defaultLayoutHeight = m_defaultLayoutSize.height(); + + int minWidth = defaultLayoutWidth; + int maxWidth = defaultMaxLayoutSize().width(); + int maxHeight = defaultMaxLayoutSize().height(); + + // If the load state is none then we haven't actually got anything yet, but we need to layout + // the entire page so that the user sees the entire page (unrendered) instead of just part of it. + if (m_loadState == None) + return IntSize(defaultLayoutWidth, defaultLayoutHeight); + + if (m_viewMode == FixedDesktop) { + int width = maxWidth; + // if the defaultLayoutHeight is at minimum, it probably was set as 0 + // and clamped, meaning it's effectively not set. (Even if it happened + // to be set exactly to the minimum, it's too small to be useful.) So + // ignore it. + int height; + if (defaultLayoutHeight <= minimumLayoutSize.height()) + height = maxHeight; + else + height = ceilf(static_cast<float>(width) / static_cast<float>(defaultLayoutWidth) * static_cast<float>(defaultLayoutHeight)); + return IntSize(width, height); + } + + if (m_viewMode == Desktop) { + // If we detect an overflow larger than the contents size then use that instead since + // it'll still be clamped by the maxWidth below... + int width = std::max(absoluteVisibleOverflowSize().width(), contentsSize().width()); + + if (snapToIncrement) { + // Snap to increments of defaultLayoutWidth / 2.0. + float factor = static_cast<float>(width) / (defaultLayoutWidth / 2.0); + factor = ceilf(factor); + width = (defaultLayoutWidth / 2.0) * factor; + } + + if (width < minWidth) + width = minWidth; + if (width > maxWidth) + width = maxWidth; + int height = ceilf(static_cast<float>(width) / static_cast<float>(defaultLayoutWidth) * static_cast<float>(defaultLayoutHeight)); + return IntSize(width, height); + } + + if (m_webSettings->isZoomToFitOnLoad()) { + // We need to clamp the layout width to the minimum of the layout + // width or the content width. This is important under rotation for mobile + // websites. We want the page to remain layouted at the same width which + // it was loaded with, and instead change the zoom level to fit to screen. + // The height is welcome to adapt to the height used in the new orientation, + // otherwise we will get a grey bar below the web page. + if (m_mainFrame->view() && !contentsSize().isEmpty()) + minWidth = contentsSize().width(); + else { + // If there is no contents width, use the minimum of screen width + // and layout width to shape the first layout to a contents width + // that we could reasonably zoom to fit, in a manner that takes + // orientation into account and still respects a small default + // layout width. +#if ENABLE(ORIENTATION_EVENTS) + minWidth = m_mainFrame->orientation() % 180 + ? Platform::Graphics::Screen::height() + : Platform::Graphics::Screen::width(); +#else + minWidth = Platform::Graphics::Screen::width(); +#endif + } + } + + return IntSize(std::min(minWidth, defaultLayoutWidth), defaultLayoutHeight); +} + +BackingStoreClient* WebPagePrivate::backingStoreClientForFrame(const Frame* frame) const +{ + ASSERT(frame); + BackingStoreClient* backingStoreClient = 0; + if (m_backingStoreClientForFrameMap.contains(frame)) + backingStoreClient = m_backingStoreClientForFrameMap.get(frame); + return backingStoreClient; +} + +void WebPagePrivate::addBackingStoreClientForFrame(const Frame* frame, BackingStoreClient* client) +{ + ASSERT(frame); + ASSERT(client); + m_backingStoreClientForFrameMap.add(frame, client); +} + +void WebPagePrivate::removeBackingStoreClientForFrame(const Frame* frame) +{ + ASSERT(frame); + if (m_backingStoreClientForFrameMap.contains(frame)) + m_backingStoreClientForFrameMap.remove(frame); +} + + +void WebPagePrivate::clearDocumentData(const Document* documentGoingAway) +{ + ASSERT(documentGoingAway); + if (m_currentContextNode && m_currentContextNode->document() == documentGoingAway) + m_currentContextNode = 0; + + if (m_currentPinchZoomNode && m_currentPinchZoomNode->document() == documentGoingAway) + m_currentPinchZoomNode = 0; + + if (m_currentBlockZoomAdjustedNode && m_currentBlockZoomAdjustedNode->document() == documentGoingAway) + m_currentBlockZoomAdjustedNode = 0; + + if (m_inRegionScrollStartingNode && m_inRegionScrollStartingNode->document() == documentGoingAway) + m_inRegionScrollStartingNode = 0; + + Node* nodeUnderFatFinger = m_touchEventHandler->lastFatFingersResult().node(); + if (nodeUnderFatFinger && nodeUnderFatFinger->document() == documentGoingAway) + m_touchEventHandler->resetLastFatFingersResult(); + + // NOTE: m_fullscreenVideoNode, m_fullScreenPluginView and m_pluginViews + // are cleared in other methods already. +} + +typedef bool (*PredicateFunction)(RenderLayer*); +static bool isPositionedContainer(RenderLayer* layer) +{ + RenderObject* o = layer->renderer(); + return o->isRenderView() || o->isPositioned() || o->isRelPositioned() || layer->hasTransform(); +} + +static bool isNonRenderViewFixedPositionedContainer(RenderLayer* layer) +{ + RenderObject* o = layer->renderer(); + if (o->isRenderView()) + return false; + + return o->isPositioned() && o->style()->position() == FixedPosition; +} + +static bool isFixedPositionedContainer(RenderLayer* layer) +{ + RenderObject* o = layer->renderer(); + return o->isRenderView() || (o->isPositioned() && o->style()->position() == FixedPosition); +} + +static RenderLayer* findAncestorOrSelfNotMatching(PredicateFunction predicate, RenderLayer* layer) +{ + RenderLayer* curr = layer; + while (curr && !predicate(curr)) + curr = curr->parent(); + + return curr; +} + +RenderLayer* WebPagePrivate::enclosingFixedPositionedAncestorOrSelfIfFixedPositioned(RenderLayer* layer) +{ + return findAncestorOrSelfNotMatching(&isFixedPositionedContainer, layer); +} + +RenderLayer* WebPagePrivate::enclosingPositionedAncestorOrSelfIfPositioned(RenderLayer* layer) +{ + return findAncestorOrSelfNotMatching(&isPositionedContainer, layer); +} + +static inline Frame* frameForNode(Node* node) +{ + Node* origNode = node; + for (; node; node = node->parentNode()) { + if (RenderObject* renderer = node->renderer()) { + if (renderer->isRenderView()) { + if (FrameView* view = toRenderView(renderer)->frameView()) { + if (Frame* frame = view->frame()) + return frame; + } + } + if (renderer->isWidget()) { + Widget* widget = toRenderWidget(renderer)->widget(); + if (widget && widget->isFrameView()) { + if (Frame* frame = static_cast<FrameView*>(widget)->frame()) + return frame; + } + } + } + } + + for (node = origNode; node; node = node->parentNode()) { + if (Document* doc = node->document()) { + if (Frame* frame = doc->frame()) + return frame; + } + } + + return 0; +} + +static IntRect getNodeWindowRect(Node* node) +{ + if (Frame* frame = frameForNode(node)) { + if (FrameView* view = frame->view()) + return view->contentsToWindow(node->getRect()); + } + ASSERT_NOT_REACHED(); + return IntRect(); +} + +IntRect WebPagePrivate::getRecursiveVisibleWindowRect(ScrollView* view, bool noClipOfMainFrame) +{ + ASSERT(m_mainFrame); + + // Don't call this function asking to not clip the main frame providing only + // the main frame. All that can be returned is the content rect which + // isn't what this function is for. + if (noClipOfMainFrame && view == m_mainFrame->view()) { + ASSERT_NOT_REACHED(); + return IntRect(IntPoint::zero(), view->contentsSize()); + } + + IntRect visibleWindowRect(view->contentsToWindow(view->visibleContentRect(false))); + if (view->parent() && !(noClipOfMainFrame && view->parent() == m_mainFrame->view())) { + // Intersect with parent visible rect. + visibleWindowRect.intersect(getRecursiveVisibleWindowRect(view->parent(), noClipOfMainFrame)); + } + return visibleWindowRect; +} + +void WebPage::assignFocus(Platform::FocusDirection direction) +{ + d->assignFocus(direction); +} + +void WebPagePrivate::assignFocus(Platform::FocusDirection direction) +{ + ASSERT((int) Platform::FocusDirectionNone == (int) FocusDirectionNone); + ASSERT((int) Platform::FocusDirectionForward == (int) FocusDirectionForward); + ASSERT((int) Platform::FocusDirectionBackward == (int) FocusDirectionBackward); + + // First we clear the focus, since we want to focus either initial or the last + // focusable element in the webpage (according to the TABINDEX), or simply clear + // the focus. + clearFocusNode(); + + switch (direction) { + case FocusDirectionForward: + case FocusDirectionBackward: + m_page->focusController()->setInitialFocus((FocusDirection) direction, 0); + break; + case FocusDirectionNone: + break; + default: + ASSERT_NOT_REACHED(); + } +} + +Platform::IntRect WebPagePrivate::focusNodeRect() +{ + Frame* frame = focusedOrMainFrame(); + if (!frame) + return Platform::IntRect(); + + Document* doc = frame->document(); + FrameView* view = frame->view(); + if (!doc || !view || view->needsLayout()) + return Platform::IntRect(); + + IntRect focusRect = rectForNode(doc->focusedNode()); + focusRect = adjustRectOffsetForFrameOffset(focusRect, doc->focusedNode()); + focusRect = mapToTransformed(focusRect); + clipToTransformedContentsRect(focusRect); + return focusRect; +} + +PassRefPtr<Node> WebPagePrivate::contextNode(TargetDetectionStrategy strategy) +{ + EventHandler* eventHandler = focusedOrMainFrame()->eventHandler(); + const FatFingersResult lastFatFingersResult = m_touchEventHandler->lastFatFingersResult(); + bool isTouching = lastFatFingersResult.isValid() && strategy == RectBased; + + // Unpress the mouse button always. + if (eventHandler->mousePressed()) + eventHandler->setMousePressed(false); + + // Check if we're using LinkToLink and the user is not touching the screen. + if (m_webSettings->doesGetFocusNodeContext() && !isTouching) { + RefPtr<Node> node; + node = m_page->focusController()->focusedOrMainFrame()->document()->focusedNode(); + if (node) { + IntRect visibleRect = IntRect(IntPoint(), actualVisibleSize()); + if (!visibleRect.intersects(getNodeWindowRect(node.get()))) + return 0; + } + return node.release(); + } + + // Check for text input. + if (isTouching && lastFatFingersResult.isTextInput()) + return lastFatFingersResult.node(FatFingersResult::ShadowContentNotAllowed); + + IntPoint contentPos; + if (isTouching) + contentPos = lastFatFingersResult.adjustedPosition(); + else + contentPos = mapFromViewportToContents(m_lastMouseEvent.pos()); + + if (strategy == RectBased) { + FatFingersResult result = FatFingers(this, lastFatFingersResult.adjustedPosition(), FatFingers::Text).findBestPoint(); + return result.node(FatFingersResult::ShadowContentNotAllowed); + } + + HitTestResult result = eventHandler->hitTestResultAtPoint(contentPos, false /*allowShadowContent*/); + return result.innerNode(); +} + +static inline int distanceBetweenPoints(IntPoint p1, IntPoint p2) +{ + // Change int to double, because (dy * dy) can cause int overflow in reality, e.g, (-46709 * -46709). + double dx = static_cast<double>(p1.x() - p2.x()); + double dy = static_cast<double>(p1.y() - p2.y()); + return sqrt((dx * dx) + (dy * dy)); +} + +Node* WebPagePrivate::bestNodeForZoomUnderPoint(const IntPoint& point) +{ + IntPoint pt = mapFromTransformed(point); + IntRect clickRect(pt.x() - blockClickRadius, pt.y() - blockClickRadius, 2 * blockClickRadius, 2 * blockClickRadius); + Node* originalNode = nodeForZoomUnderPoint(point); + if (!originalNode) + return 0; + Node* node = bestChildNodeForClickRect(originalNode, clickRect); + return node ? adjustedBlockZoomNodeForZoomLimits(node) : adjustedBlockZoomNodeForZoomLimits(originalNode); +} + +Node* WebPagePrivate::bestChildNodeForClickRect(Node* parentNode, const IntRect& clickRect) +{ + if (!parentNode) + return 0; + + int bestDistance = std::numeric_limits<int>::max(); + + Node* node = parentNode->firstChild(); + Node* bestNode = 0; + for (; node; node = node->nextSibling()) { + IntRect rect = rectForNode(node); + if (!clickRect.intersects(rect)) + continue; + + int distance = distanceBetweenPoints(rect.center(), clickRect.center()); + Node* bestChildNode = bestChildNodeForClickRect(node, clickRect); + if (bestChildNode) { + IntRect bestChildRect = rectForNode(bestChildNode); + int bestChildDistance = distanceBetweenPoints(bestChildRect.center(), clickRect.center()); + if (bestChildDistance < distance && bestChildDistance < bestDistance) { + bestNode = bestChildNode; + bestDistance = bestChildDistance; + } else { + if (distance < bestDistance) { + bestNode = node; + bestDistance = distance; + } + } + } else { + if (distance < bestDistance) { + bestNode = node; + bestDistance = distance; + } + } + } + + return bestNode; +} + +double WebPagePrivate::maxBlockZoomScale() const +{ + return std::min(maximumBlockZoomScale, maximumScale()); +} + +Node* WebPagePrivate::nodeForZoomUnderPoint(const IntPoint& point) +{ + if (!m_mainFrame) + return 0; + + HitTestResult result = m_mainFrame->eventHandler()->hitTestResultAtPoint(mapFromTransformed(point), false); + + Node* node = result.innerNonSharedNode(); + + if (!node) + return 0; + + RenderObject* renderer = node->renderer(); + while (!renderer) { + node = node->parentNode(); + renderer = node->renderer(); + } + + return node; +} + +Node* WebPagePrivate::adjustedBlockZoomNodeForZoomLimits(Node* node) +{ + Node* initialNode = node; + RenderObject* renderer = node->renderer(); + bool acceptableNodeSize = newScaleForBlockZoomRect(rectForNode(node), 1.0, 0) < maxBlockZoomScale(); + + while (!renderer || !acceptableNodeSize) { + node = node->parentNode(); + + if (!node) + return initialNode; + + renderer = node->renderer(); + acceptableNodeSize = newScaleForBlockZoomRect(rectForNode(node), 1.0, 0) < maxBlockZoomScale(); + } + + return node; +} + +bool WebPagePrivate::compareNodesForBlockZoom(Node* n1, Node* n2) +{ + if (!n1 || !n2) + return false; + + return (n2 == n1) || n2->isDescendantOf(n1); +} + +double WebPagePrivate::newScaleForBlockZoomRect(const IntRect& rect, double oldScale, double margin) +{ + if (rect.isEmpty()) + return std::numeric_limits<double>::max(); + + ASSERT(rect.width() + margin); + + double newScale = oldScale * static_cast<double>(transformedActualVisibleSize().width()) / (rect.width() + margin); + + return newScale; +} + +IntRect WebPagePrivate::rectForNode(Node* node) +{ + if (!node) + return IntRect(); + + RenderObject* renderer = node->renderer(); + + if (!renderer) + return IntRect(); + + // Return rect in un-transformed content coordinates. + IntRect blockRect; + + // FIXME: Ensure this works with iframes. + if (m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabled && renderer->isText()) { + RenderBlock* renderBlock = renderer->containingBlock(); + int xOffset = 0; + int yOffset = 0; + while (!renderBlock->isRoot()) { + xOffset += renderBlock->x(); + yOffset += renderBlock->y(); + renderBlock = renderBlock->containingBlock(); + } + const RenderText* renderText = toRenderText(renderer); + IntRect linesBox = renderText->linesBoundingBox(); + blockRect = IntRect(xOffset + linesBox.x(), yOffset + linesBox.y(), linesBox.width(), linesBox.height()); + } else + blockRect = renderer->absoluteClippedOverflowRect(); + + if (renderer->isText()) { + RenderBlock* rb = renderer->containingBlock(); + + // Inefficient? Way to find width when floats intersect a block. + int blockWidth = 0; + int lineCount = rb->lineCount(); + for (int i = 0; i < lineCount; i++) + blockWidth = max(blockWidth, rb->availableLogicalWidthForLine(i, false)); + + blockRect.setWidth(blockWidth); + blockRect.setX(blockRect.x() + rb->logicalLeftOffsetForLine(1, false)); + } + + // Strip off padding. + if (renderer->style()->hasPadding()) { + blockRect.setX(blockRect.x() + renderer->style()->paddingLeft().value()); + blockRect.setY(blockRect.y() + renderer->style()->paddingTop().value()); + blockRect.setWidth(blockRect.width() - renderer->style()->paddingRight().value()); + blockRect.setHeight(blockRect.height() - renderer->style()->paddingBottom().value()); + } + + return blockRect; +} + +IntPoint WebPagePrivate::frameOffset(const Frame* frame) const +{ + ASSERT(frame); + + // FIXME: This function can be called when page is being destroyed and JS triggers selection change. + // We could break the call chain at upper levels, but I think it is better to check the frame pointer + // here because the pointer is explicitly cleared in WebPage::destroy(). + if (!mainFrame()) + return IntPoint(); + + // Convert 0,0 in the frame's coordinate system to window coordinates to + // get the frame's global position, and return this position in the main + // frame's coordinates. (So the main frame's coordinates will be 0,0.) + return mainFrame()->view()->windowToContents(frame->view()->contentsToWindow(IntPoint::zero())); +} + +IntRect WebPagePrivate::adjustRectOffsetForFrameOffset(const IntRect& rect, const Node* node) +{ + if (!node) + return rect; + + // Adjust the offset of the rect if it is in an iFrame/frame or set of iFrames/frames. + // FIXME: can we just use frameOffset instead of this big routine? + const Node* tnode = node; + IntRect adjustedRect = rect; + do { + Frame* frame = tnode->document()->frame(); + if (!frame) + continue; + + Node* ownerNode = static_cast<Node*>(frame->ownerElement()); + tnode = ownerNode; + if (ownerNode && (ownerNode->hasTagName(HTMLNames::iframeTag) || ownerNode->hasTagName(HTMLNames::frameTag))) { + IntRect iFrameRect; + do { + iFrameRect = rectForNode(ownerNode); + adjustedRect.move(iFrameRect.x(), iFrameRect.y()); + adjustedRect.intersect(iFrameRect); + ownerNode = ownerNode->parentNode(); + } while (iFrameRect.isEmpty() && ownerNode); + } else + break; + } while (tnode = tnode->parentNode()); + + return adjustedRect; +} + +IntRect WebPagePrivate::blockZoomRectForNode(Node* node) +{ + if (!node || contentsSize().isEmpty()) + return IntRect(); + + Node* tnode = node; + m_currentBlockZoomAdjustedNode = tnode; + + IntRect blockRect = rectForNode(tnode); + IntRect originalRect = blockRect; + + int originalArea = originalRect.width() * originalRect.height(); + int pageArea = contentsSize().width() * contentsSize().height(); + double blockToPageRatio = static_cast<double>(1 - originalArea / pageArea); + double blockExpansionRatio = 5.0 * blockToPageRatio * blockToPageRatio; + + if (!tnode->hasTagName(HTMLNames::imgTag) && !tnode->hasTagName(HTMLNames::inputTag) && !tnode->hasTagName(HTMLNames::textareaTag)) { + while (tnode = tnode->parentNode()) { + ASSERT(tnode); + IntRect tRect = rectForNode(tnode); + int tempBlockArea = tRect.width() * tRect.height(); + // Don't expand the block if it will be too large relative to the content. + if (static_cast<double>(1 - tempBlockArea / pageArea) < minimumExpandingRatio) + break; + if (tRect.isEmpty()) + continue; // No renderer. + if (tempBlockArea < 1.1 * originalArea) + continue; // The size of this parent is very close to the child, no need to go to this parent. + // Don't expand the block if the parent node size is already almost the size of actual visible size. + IntSize actualSize = actualVisibleSize(); + if (static_cast<double>(1 - tRect.width() / actualSize.width()) < minimumExpandingRatio) + break; + if (tempBlockArea < blockExpansionRatio * originalArea) { + blockRect = tRect; + m_currentBlockZoomAdjustedNode = tnode; + } else + break; + } + } + + blockRect = adjustRectOffsetForFrameOffset(blockRect, node); + blockRect = mapToTransformed(blockRect); + clipToTransformedContentsRect(blockRect); + +#if DEBUG_BLOCK_ZOOM + // Re-paint the backingstore to screen to erase other annotations. + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::Blit); + + // Render a black square over the calculated block and a gray square over the original block for visual inspection. + originalRect = mapToTransformed(originalRect); + clipToTransformedContentsRect(originalRect); + IntRect renderRect = mapFromTransformedContentsToTransformedViewport(blockRect); + IntRect originalRenderRect = mapFromTransformedContentsToTransformedViewport(originalRect); + IntSize viewportSize = transformedViewportSize(); + renderRect.intersect(IntRect(0, 0, viewportSize.width(), viewportSize.height())); + originalRenderRect.intersect(IntRect(0, 0, viewportSize.width(), viewportSize.height())); + m_backingStore->d->clearWindow(renderRect, 0, 0, 0); + m_backingStore->d->clearWindow(originalRenderRect, 120, 120, 120); + m_backingStore->d->invalidateWindow(renderRect); +#endif + + return blockRect; +} + +void WebPage::blockZoomAnimationFinished() +{ + d->zoomBlock(); +} + +// This function should not be called directly. +// It is called after the animation ends (see above). +void WebPagePrivate::zoomBlock() +{ + if (!m_mainFrame) + return; + + IntPoint anchor(roundUntransformedPoint(mapFromTransformedFloatPoint(m_finalBlockPoint))); + bool willUseTextReflow = false; + +#if ENABLE(VIEWPORT_REFLOW) + willUseTextReflow = m_webPage->settings()->textReflowMode() != WebSettings::TextReflowDisabled; + toggleTextReflowIfEnabledForBlockZoomOnly(m_shouldReflowBlock); + setNeedsLayout(); +#endif + + TransformationMatrix zoom; + zoom.scale(m_blockZoomFinalScale); + *m_transformationMatrix = zoom; + m_client->resetBitmapZoomScale(m_blockZoomFinalScale); + m_backingStore->d->suspendScreenAndBackingStoreUpdates(); + updateViewportSize(); + +#if ENABLE(VIEWPORT_REFLOW) + requestLayoutIfNeeded(); + if (willUseTextReflow && m_shouldReflowBlock) { + IntRect reflowedRect = rectForNode(m_currentBlockZoomAdjustedNode.get()); + reflowedRect = adjustRectOffsetForFrameOffset(reflowedRect, m_currentBlockZoomAdjustedNode.get()); + reflowedRect.move(roundTransformedPoint(m_finalBlockPointReflowOffset).x(), roundTransformedPoint(m_finalBlockPointReflowOffset).y()); + RenderObject* renderer = m_currentBlockZoomAdjustedNode->renderer(); + IntPoint topLeftPoint(reflowedRect.location()); + if (renderer && renderer->isText()) { + ETextAlign textAlign = renderer->style()->textAlign(); + IntPoint textAnchor; + switch (textAlign) { + case CENTER: + case WEBKIT_CENTER: + textAnchor = IntPoint(reflowedRect.x() + (reflowedRect.width() - actualVisibleSize().width()) / 2, topLeftPoint.y()); + break; + case LEFT: + case WEBKIT_LEFT: + textAnchor = topLeftPoint; + break; + case RIGHT: + case WEBKIT_RIGHT: + textAnchor = IntPoint(reflowedRect.x() + reflowedRect.width() - actualVisibleSize().width(), topLeftPoint.y()); + break; + case TAAUTO: + case JUSTIFY: + default: + if (renderer->style()->isLeftToRightDirection()) + textAnchor = topLeftPoint; + else + textAnchor = IntPoint(reflowedRect.x() + reflowedRect.width() - actualVisibleSize().width(), topLeftPoint.y()); + break; + } + setScrollPosition(textAnchor); + } else { + renderer->style()->isLeftToRightDirection() + ? setScrollPosition(topLeftPoint) + : setScrollPosition(IntPoint(reflowedRect.x() + reflowedRect.width() - actualVisibleSize().width(), topLeftPoint.y())); + } + } else if (willUseTextReflow) { + IntRect finalRect = rectForNode(m_currentBlockZoomAdjustedNode.get()); + finalRect = adjustRectOffsetForFrameOffset(finalRect, m_currentBlockZoomAdjustedNode.get()); + setScrollPosition(IntPoint(0, finalRect.y() + m_finalBlockPointReflowOffset.y())); + resetBlockZoom(); + } +#endif + if (!willUseTextReflow) { + setScrollPosition(anchor); + if (!m_shouldReflowBlock) + resetBlockZoom(); + } + + notifyTransformChanged(); + m_backingStore->d->clearWindow(); + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::RenderAndBlit); + m_client->zoomChanged(m_webPage->isMinZoomed(), m_webPage->isMaxZoomed(), !shouldZoomOnEscape(), currentScale()); +} + + +void WebPagePrivate::resetBlockZoom() +{ + m_currentBlockZoomNode = 0; + m_currentBlockZoomAdjustedNode = 0; + m_shouldReflowBlock = false; +} + +WebPage::WebPage(WebPageClient* client, const WebString& pageGroupName, const Platform::IntRect& rect) +{ + globalInitialize(); + d = new WebPagePrivate(this, client, rect); + d->init(pageGroupName); +} + +void WebPage::destroyWebPageCompositor() +{ +#if USE(ACCELERATED_COMPOSITING) + // Destroy the layer renderer in a sync command before we destroy the backing store, + // to flush any pending compositing messages on the compositing thread. + // The backing store is indirectly deleted by the 'detachFromParent' call below. + d->syncDestroyCompositorOnCompositingThread(); +#endif +} + +void WebPage::destroy() +{ + // TODO: need to verify if this call needs to be made before calling + // WebPage::destroyWebPageCompositor() + d->m_backingStore->d->suspendScreenAndBackingStoreUpdates(); + + // Close the backforward list and release the cached pages. + d->m_page->backForward()->close(); + pageCache()->releaseAutoreleasedPagesNow(); + + FrameLoader* loader = d->m_mainFrame->loader(); + + // Remove main frame's backing store client from the map + // to prevent FrameLoaderClientBlackyBerry::detachFromParent2(), + // which is called by loader->detachFromParent(), deleting it. + // We will delete it in ~WebPagePrivate(). + // Reason: loader->detachFromParent() may ping back to backing store + // indirectly through ChromeClientBlackBerry::invalidateContentsAndWindow(). + // see RIM PR #93256. + d->removeBackingStoreClientForFrame(d->m_mainFrame); + + // Set m_mainFrame to 0 to avoid calls back in to the backingstore during webpage deletion. + d->m_mainFrame = 0; + if (loader) + loader->detachFromParent(); + + delete this; +} + +WebPage::~WebPage() +{ + delete d; + d = 0; +} + +WebPageClient* WebPage::client() const +{ + return d->m_client; +} + +void WebPage::load(const char* url, const char* networkToken, bool isInitial) +{ + d->load(url, networkToken, "GET", Platform::NetworkRequest::UseProtocolCachePolicy, 0, 0, 0, 0, isInitial, false); +} + +void WebPage::loadExtended(const char* url, const char* networkToken, const char* method, Platform::NetworkRequest::CachePolicy cachePolicy, const char* data, size_t dataLength, const char* const* headers, size_t headersLength, bool mustHandleInternally) +{ + d->load(url, networkToken, method, cachePolicy, data, dataLength, headers, headersLength, false, mustHandleInternally, false, ""); +} + +void WebPage::loadFile(const char* path, const char* overrideContentType) +{ + std::string fileUrl(path); + if (!fileUrl.find("/")) + fileUrl.insert(0, "file://"); + else if (fileUrl.find("file:///")) + return; + + d->load(fileUrl.c_str(), 0, "GET", Platform::NetworkRequest::UseProtocolCachePolicy, 0, 0, 0, 0, false, false, false, overrideContentType); +} + +void WebPage::loadString(const char* string, const char* baseURL, const char* mimeType, const char* failingURL) +{ + d->loadString(string, baseURL, mimeType, failingURL); +} + +void WebPage::download(const Platform::NetworkRequest& request) +{ + d->load(request.getUrlRef().c_str(), 0, "GET", Platform::NetworkRequest::UseProtocolCachePolicy, 0, 0, 0, 0, false, false, true, ""); +} + +bool WebPage::executeJavaScript(const char* script, JavaScriptDataType& returnType, WebString& returnValue) +{ + return d->executeJavaScript(script, returnType, returnValue); +} + +bool WebPage::executeJavaScriptInIsolatedWorld(const std::wstring& script, JavaScriptDataType& returnType, WebString& returnValue) +{ + // On our platform wchar_t is unsigned int and UChar is unsigned short + // so we have to convert using ICU conversion function + int lengthCopied = 0; + UErrorCode error = U_ZERO_ERROR; + const int length = script.length() + 1 /*null termination char*/; + UChar data[length]; + + // FIXME: PR 138162 is giving U_INVALID_CHAR_FOUND error. + u_strFromUTF32(data, length, &lengthCopied, reinterpret_cast<const UChar32*>(script.c_str()), script.length(), &error); + BLACKBERRY_ASSERT(error == U_ZERO_ERROR); + if (error != U_ZERO_ERROR) { + Platform::logAlways(Platform::LogLevelCritical, "WebPage::executeJavaScriptInIsolatedWorld failed to convert UTF16 to JavaScript!"); + return false; + } + String str = String(data, lengthCopied); + ScriptSourceCode sourceCode(str, KURL()); + return d->executeJavaScriptInIsolatedWorld(sourceCode, returnType, returnValue); +} + +bool WebPage::executeJavaScriptInIsolatedWorld(const char* script, JavaScriptDataType& returnType, WebString& returnValue) +{ + ScriptSourceCode sourceCode(String::fromUTF8(script), KURL()); + return d->executeJavaScriptInIsolatedWorld(sourceCode, returnType, returnValue); +} + +void WebPage::stopLoading() +{ + d->stopCurrentLoad(); +} + +void WebPage::prepareToDestroy() +{ + d->prepareToDestroy(); +} + +int WebPage::backForwardListLength() const +{ + return d->m_page->getHistoryLength(); +} + +bool WebPage::canGoBackOrForward(int delta) const +{ + return d->m_page->canGoBackOrForward(delta); +} + +bool WebPage::goBackOrForward(int delta) +{ + if (d->m_page->canGoBackOrForward(delta)) { + d->m_page->goBackOrForward(delta); + return true; + } + return false; +} + +void WebPage::goToBackForwardEntry(BackForwardId id) +{ + HistoryItem* item = historyItemFromBackForwardId(id); + ASSERT(item); + d->m_page->goToItem(item, FrameLoadTypeIndexedBackForward); +} + +void WebPage::reload() +{ + d->m_mainFrame->loader()->reload(/* bypassCache */ true); +} + +void WebPage::reloadFromCache() +{ + d->m_mainFrame->loader()->reload(/* bypassCache */ false); +} + +WebSettings* WebPage::settings() const +{ + return d->m_webSettings; +} + +bool WebPage::isVisible() const +{ + return d->m_visible; +} + +void WebPage::setVisible(bool visible) +{ + if (d->m_visible == visible) + return; + + d->m_visible = visible; + + if (!visible) { + d->suspendBackingStore(); + + // Remove this WebPage from the visible pages list. + size_t foundIndex = visibleWebPages()->find(this); + if (foundIndex != WTF::notFound) + visibleWebPages()->remove(foundIndex); + + // Return the backing store to the last visible WebPage. + if (BackingStorePrivate::currentBackingStoreOwner() == this && !visibleWebPages()->isEmpty()) + visibleWebPages()->last()->d->resumeBackingStore(); + +#if USE(ACCELERATED_COMPOSITING) + // Root layer commit is not necessary for invisible tabs. + // And release layer resources can reduce memory consumption. + d->suspendRootLayerCommit(); +#endif + return; + } + +#if USE(ACCELERATED_COMPOSITING) + d->resumeRootLayerCommit(); +#endif + + // Push this WebPage to the top of the visible pages list. + if (!visibleWebPages()->isEmpty() && visibleWebPages()->last() != this) { + size_t foundIndex = visibleWebPages()->find(this); + if (foundIndex != WTF::notFound) + visibleWebPages()->remove(foundIndex); + } + visibleWebPages()->append(this); + + if (BackingStorePrivate::currentBackingStoreOwner() + && BackingStorePrivate::currentBackingStoreOwner() != this) + BackingStorePrivate::currentBackingStoreOwner()->d->suspendBackingStore(); + + // resumeBackingStore will set the current owner to this webpage. + // If we set the owner prematurely, then the tiles will not be reset. + d->resumeBackingStore(); +} + +void WebPagePrivate::selectionChanged(Frame* frame) +{ + m_inputHandler->selectionChanged(); + + // FIXME: This is a hack! + // To ensure the selection being changed has its frame 'focused', lets + // set it as focused ourselves (PR #104724). + m_page->focusController()->setFocusedFrame(frame); +} + +void WebPagePrivate::updateDelegatedOverlays(bool dispatched) +{ + // Track a dispatched message, we don't want to flood the webkit thread. + // There can be as many as one more message enqued as needed but never less. + if (dispatched) + m_updateDelegatedOverlaysDispatched = false; + else if (m_updateDelegatedOverlaysDispatched) { + // Early return if there is message already pending on the webkit thread. + return; + } + + if (Platform::webKitThreadMessageClient()->isCurrentThread()) { + // Must be called on the WebKit thread. + if (m_selectionHandler->isSelectionActive()) + m_selectionHandler->selectionPositionChanged(true /* visualChangeOnly */); + + } else if (m_selectionHandler->isSelectionActive()) { + // Don't bother dispatching to webkit thread if selection and tap highlight are not active. + m_updateDelegatedOverlaysDispatched = true; + Platform::webKitThreadMessageClient()->dispatchMessage(Platform::createMethodCallMessage(&WebPagePrivate::updateDelegatedOverlays, this, true /*dispatched*/)); + } +} + +void WebPage::setCaretHighlightStyle(Platform::CaretHighlightStyle style) +{ +} + +bool WebPage::setBatchEditingActive(bool active) +{ + return d->m_inputHandler->setBatchEditingActive(active); +} + +bool WebPage::setInputSelection(unsigned start, unsigned end) +{ + return d->m_inputHandler->setSelection(start, end); +} + +int WebPage::inputCaretPosition() const +{ + return d->m_inputHandler->caretPosition(); +} + +void WebPage::popupListClosed(int size, bool* selecteds) +{ + d->m_inputHandler->setPopupListIndexes(size, selecteds); +} + +void WebPage::popupListClosed(int index) +{ + d->m_inputHandler->setPopupListIndex(index); +} + +void WebPage::setDateTimeInput(const WebString& value) +{ + d->m_inputHandler->setInputValue(String(value.impl())); +} + +void WebPage::setColorInput(const WebString& value) +{ + d->m_inputHandler->setInputValue(String(value.impl())); +} + +ActiveNodeContext WebPage::activeNodeContext(TargetDetectionStrategy strategy) const +{ + return d->activeNodeContext(strategy); +} + +void WebPage::setVirtualViewportSize(int width, int height) +{ + d->m_virtualViewportWidth = width; + d->m_virtualViewportHeight = height; +} + +void WebPage::resetVirtualViewportOnCommitted(bool reset) +{ + d->m_resetVirtualViewportOnCommitted = reset; +} + +IntSize WebPagePrivate::recomputeVirtualViewportFromViewportArguments() +{ + static ViewportArguments defaultViewportArguments; + if (m_viewportArguments == defaultViewportArguments) + return IntSize(); + + int desktopWidth = defaultMaxLayoutSize().width(); + int deviceWidth = Platform::Graphics::Screen::width(); + int deviceHeight = Platform::Graphics::Screen::height(); + FloatSize currentPPI = Platform::Graphics::Screen::pixelsPerInch(-1); + int deviceDPI = int(roundf((currentPPI.width() + currentPPI.height()) / 2)); + if (m_viewportArguments.targetDensityDpi == ViewportArguments::ValueAuto) { + // Auto means 160dpi if we leave it alone. This looks terrible for pages wanting 1:1. + // FIXME: This is insufficient for devices with high dpi, as they will render content unreadably small. + m_viewportArguments.targetDensityDpi = deviceDPI; + } + + ViewportAttributes result = computeViewportAttributes(m_viewportArguments, desktopWidth, deviceWidth, deviceHeight, deviceDPI, m_defaultLayoutSize); + return IntSize(result.layoutSize.width(), result.layoutSize.height()); +} + +#if ENABLE(EVENT_MODE_METATAGS) +void WebPagePrivate::didReceiveCursorEventMode(CursorEventMode mode) +{ + if (mode != m_cursorEventMode) + m_client->cursorEventModeChanged(toPlatformCursorEventMode(mode)); + m_cursorEventMode = mode; +} + +void WebPagePrivate::didReceiveTouchEventMode(TouchEventMode mode) +{ + if (mode != m_touchEventMode) + m_client->touchEventModeChanged(toPlatformTouchEventMode(mode)); + m_touchEventMode = mode; +} +#endif + +void WebPagePrivate::dispatchViewportPropertiesDidChange(const ViewportArguments& arguments) +{ + static ViewportArguments defaultViewportArguments; + if (arguments == defaultViewportArguments) + return; + + m_viewportArguments = arguments; + + // 0 width or height in viewport arguments makes no sense, and results in a very large initial scale. + // In real world, a 0 width or height is usually caused by a syntax error in "content" field of viewport + // meta tag, for example, using semicolon instead of comma as separator ("width=device-width; initial-scale=1.0"). + // We don't have a plan to tolerate the semicolon separator, but we can avoid applying 0 width/height. + // I default it to ValueDeviceWidth rather than ValueAuto because in more cases the web site wants "device-width" + // when they specify the viewport width. + if (!m_viewportArguments.width) + m_viewportArguments.width = ViewportArguments::ValueDeviceWidth; + if (!m_viewportArguments.height) + m_viewportArguments.height = ViewportArguments::ValueDeviceHeight; + + setUserScalable(arguments.userScalable == ViewportArguments::ValueAuto ? true : arguments.userScalable); + if (arguments.initialScale > 0) + setInitialScale(arguments.initialScale); + if (arguments.minimumScale > 0) + setMinimumScale(arguments.minimumScale); + if (arguments.maximumScale > 0) + setMaximumScale(arguments.maximumScale); + + IntSize virtualViewport = recomputeVirtualViewportFromViewportArguments(); + m_webPage->setVirtualViewportSize(virtualViewport.width(), virtualViewport.height()); + + if (loadState() == WebKit::WebPagePrivate::Committed) + zoomToInitialScaleOnLoad(); +} + +void WebPagePrivate::onInputLocaleChanged(bool isRTL) +{ + if (isRTL != m_webSettings->isWritingDirectionRTL()) { + m_webSettings->setWritingDirectionRTL(isRTL); + m_inputHandler->handleInputLocaleChanged(isRTL); + } +} + +void WebPage::setScreenOrientation(int orientation) +{ + d->m_pendingOrientation = orientation; +} + +void WebPage::applyPendingOrientationIfNeeded() +{ + if (d->m_pendingOrientation != -1) + d->setScreenOrientation(d->m_pendingOrientation); +} + +void WebPagePrivate::suspendBackingStore() +{ +#if USE(ACCELERATED_COMPOSITING) + resetCompositingSurface(); +#endif +} + +void WebPagePrivate::resumeBackingStore() +{ + ASSERT(m_webPage->isVisible()); + +#if USE(ACCELERATED_COMPOSITING) + setNeedsOneShotDrawingSynchronization(); +#endif + + bool directRendering = m_backingStore->d->shouldDirectRenderingToWindow(); + if (!m_backingStore->d->isActive() + || shouldResetTilesWhenShown() + || directRendering) { + // We need to reset all tiles so that we do not show any tiles whose content may + // have been replaced by another WebPage instance (i.e. another tab). + BackingStorePrivate::setCurrentBackingStoreOwner(m_webPage); + m_backingStore->d->orientationChanged(); // Updates tile geometry and creates visible tile buffer. + m_backingStore->d->resetTiles(true /* resetBackground */); + m_backingStore->d->updateTiles(false /* updateVisible */, false /* immediate */); + // This value may have changed, so we need to update it. + directRendering = m_backingStore->d->shouldDirectRenderingToWindow(); + if (m_backingStore->d->renderVisibleContents() && !m_backingStore->d->isSuspended() && !directRendering) + m_backingStore->d->blitVisibleContents(); + } else { + // Rendering was disabled while we were hidden, so we need to update all tiles. + m_backingStore->d->updateTiles(true /* updateVisible */, false /* immediate */); + } + + setShouldResetTilesWhenShown(false); +} + +void WebPagePrivate::setScreenOrientation(int orientation) +{ + FOR_EACH_PLUGINVIEW(m_pluginViews) + (*it)->handleOrientationEvent(orientation); + + m_pendingOrientation = -1; + +#if ENABLE(ORIENTATION_EVENTS) + if (m_mainFrame->orientation() == orientation) + return; + for (RefPtr<Frame> frame = m_mainFrame; frame; frame = frame->tree()->traverseNext()) + frame->sendOrientationChangeEvent(orientation); +#endif +} + +Platform::IntSize WebPage::viewportSize() const +{ + return d->transformedActualVisibleSize(); +} + +void WebPage::setViewportSize(const Platform::IntSize& viewportSize, bool ensureFocusElementVisible) +{ + d->setViewportSize(viewportSize, ensureFocusElementVisible); +} + +void WebPagePrivate::screenRotated() +{ + // This call will cause the client to reallocate the window buffer to new size, + // which needs to be serialized with usage of the window buffer. Accomplish + // this by sending a sync message to the compositing thread. All other usage of + // the window buffer happens on the compositing thread. + if (!Platform::userInterfaceThreadMessageClient()->isCurrentThread()) { + Platform::userInterfaceThreadMessageClient()->dispatchSyncMessage( + Platform::createMethodCallMessage(&WebPagePrivate::screenRotated, this)); + return; + } + + SurfacePool::globalSurfacePool()->notifyScreenRotated(); + m_client->notifyScreenRotated(); +} + +void WebPagePrivate::setViewportSize(const IntSize& transformedActualVisibleSize, bool ensureFocusElementVisible) +{ + if (m_pendingOrientation == -1 && transformedActualVisibleSize == this->transformedActualVisibleSize()) + return; + + // Suspend all screen updates to the backingstore to make sure no-one tries to blit + // while the window surface and the BackingStore are out of sync. + m_backingStore->d->suspendScreenAndBackingStoreUpdates(); + + // The screen rotation is a major state transition that in this case is not properly + // communicated to the backing store, since it does early return in most methods when + // not visible. + if (!m_visible || !m_backingStore->d->isActive()) + setShouldResetTilesWhenShown(true); + + bool hasPendingOrientation = m_pendingOrientation != -1; + if (hasPendingOrientation) + screenRotated(); + + // The window buffers might have been recreated, cleared, moved, etc., so: + m_backingStore->d->windowFrontBufferState()->clearBlittedRegion(); + m_backingStore->d->windowBackBufferState()->clearBlittedRegion(); + + IntSize viewportSizeBefore = actualVisibleSize(); + FloatPoint centerOfVisibleContentsRect = this->centerOfVisibleContentsRect(); + bool newVisibleRectContainsOldVisibleRect = (m_actualVisibleHeight <= transformedActualVisibleSize.height()) + && (m_actualVisibleWidth <= transformedActualVisibleSize.width()); + + bool atInitialScale = currentScale() == initialScale(); + bool atTop = !scrollPosition().y(); + bool atLeft = !scrollPosition().x(); + + // We need to reorient the visibleTileRect because the following code + // could cause BackingStore::transformChanged to be called, where it + // is used. + // It is only dependent on the transformedViewportSize which has been + // updated by now. + m_backingStore->d->createVisibleTileBuffer(); + + setDefaultLayoutSize(transformedActualVisibleSize); + + // Recompute our virtual viewport. + bool needsLayout = false; + static ViewportArguments defaultViewportArguments; + if (!(m_viewportArguments == defaultViewportArguments)) { + // We may need to infer the width and height for the viewport with respect to the rotation. + IntSize newVirtualViewport = recomputeVirtualViewportFromViewportArguments(); + ASSERT(!newVirtualViewport.isEmpty()); + m_webPage->setVirtualViewportSize(newVirtualViewport.width(), newVirtualViewport.height()); + m_mainFrame->view()->setUseFixedLayout(useFixedLayout()); + m_mainFrame->view()->setFixedLayoutSize(fixedLayoutSize()); + needsLayout = true; + } + + // We switch this strictly after recomputing our virtual viewport as zoomToFitScale is dependent + // upon these values and so is the virtual viewport recalculation. + m_actualVisibleWidth = transformedActualVisibleSize.width(); + m_actualVisibleHeight = transformedActualVisibleSize.height(); + + IntSize viewportSizeAfter = actualVisibleSize(); + + IntPoint offset(roundf((viewportSizeBefore.width() - viewportSizeAfter.width()) / 2.0), + roundf((viewportSizeBefore.height() - viewportSizeAfter.height()) / 2.0)); + + // As a special case, if we were anchored to the top left position at + // the beginning of the rotation then preserve that anchor. + if (atTop) + offset.setY(0); + if (atLeft) + offset.setX(0); + + // If we're about to overscroll, cap the offset to valid content. + IntPoint bottomRight( + scrollPosition().x() + viewportSizeAfter.width(), + scrollPosition().y() + viewportSizeAfter.height()); + + if (bottomRight.x() + offset.x() > contentsSize().width()) + offset.setX(contentsSize().width() - bottomRight.x()); + if (bottomRight.y() + offset.y() > contentsSize().height()) + offset.setY(contentsSize().height() - bottomRight.y()); + if (scrollPosition().x() + offset.x() < 0) + offset.setX(-scrollPosition().x()); + if (scrollPosition().y() + offset.y() < 0) + offset.setY(-scrollPosition().y()); + + // ...before scrolling, because the backing store will align its + // tile matrix with the viewport as reported by the ScrollView. + scrollBy(offset.x(), offset.y()); + notifyTransformedScrollChanged(); + + m_backingStore->d->orientationChanged(); + m_backingStore->d->actualVisibleSizeChanged(transformedActualVisibleSize); + + // Update view mode only after we have updated the actual + // visible size and reset the contents rect if necessary. + if (setViewMode(viewMode())) + needsLayout = true; + + // We need to update the viewport size of the WebCore::ScrollView... + updateViewportSize(!hasPendingOrientation /* setFixedReportedSize */, false /* sendResizeEvent */); + notifyTransformedContentsSizeChanged(); + + // If automatic zooming is disabled, prevent zooming below. + if (!m_webSettings->isZoomToFitOnLoad()) { + atInitialScale = false; + + // Normally, if the contents size is smaller than the layout width, + // we would zoom in. If zoom is disabled, we need to do something else, + // or there will be artifacts due to non-rendered areas outside of the + // contents size. If there is a virtual viewport, we are not allowed + // to modify the fixed layout size, however. + if (!hasVirtualViewport() && contentsSize().width() < m_defaultLayoutSize.width()) { + m_mainFrame->view()->setUseFixedLayout(useFixedLayout()); + m_mainFrame->view()->setFixedLayoutSize(m_defaultLayoutSize); + needsLayout = true; + } + } + + if (needsLayout) + setNeedsLayout(); + + // Need to resume so that the backingstore will start recording the invalidated + // rects from below. + m_backingStore->d->resumeScreenAndBackingStoreUpdates(BackingStore::None); + + // We might need to layout here to get a correct contentsSize so that zoomToFit + // is calculated correctly. + requestLayoutIfNeeded(); + + // As a special case if we were zoomed to the initial scale at the beginning + // of the rotation then preserve that zoom level even when it is zoomToFit. + double scale = atInitialScale ? initialScale() : currentScale(); + + // Do our own clamping. + scale = clampedScale(scale); + + if (hasPendingOrientation) { + // Set the fixed reported size here so that innerWidth|innerHeight works + // with this new scale. + TransformationMatrix rotationMatrix; + rotationMatrix.scale(scale); + IntRect viewportRect = IntRect(IntPoint::zero(), transformedActualVisibleSize); + IntRect actualVisibleRect = enclosingIntRect(rotationMatrix.inverse().mapRect(FloatRect(viewportRect))); + m_mainFrame->view()->setFixedReportedSize(actualVisibleRect.size()); + } + + // We're going to need to send a resize event to JavaScript because + // innerWidth and innerHeight depend on fixed reported size. + // This is how we support mobile pages where JavaScript resizes + // the page in order to get around the fixed layout size, e.g. + // google maps when it detects a mobile user agent. + if (shouldSendResizeEvent()) + m_mainFrame->eventHandler()->sendResizeEvent(); + + // As a special case if we were anchored to the top left position at the beginning + // of the rotation then preserve that anchor. + FloatPoint anchor = centerOfVisibleContentsRect; + if (atTop) + anchor.setY(0); + if (atLeft) + anchor.setX(0); + + // Try and zoom here with clamping on. + if (m_backingStore->d->shouldDirectRenderingToWindow()) { + bool success = zoomAboutPoint(scale, anchor, false /* enforceScaleClamping */, true /* forceRendering */); + if (!success && ensureFocusElementVisible) + ensureContentVisible(!newVisibleRectContainsOldVisibleRect); + } else if (!scheduleZoomAboutPoint(scale, anchor, false /* enforceScaleClamping */, true /* forceRendering */)) { + // Suspend all screen updates to the backingstore. + m_backingStore->d->suspendScreenAndBackingStoreUpdates(); + + // If the zoom failed, then we should still preserve the special case of scroll position. + IntPoint scrollPosition = this->scrollPosition(); + if (atTop) + scrollPosition.setY(0); + if (atLeft) + scrollPosition.setX(0); + setScrollPosition(scrollPosition); + + // These might have been altered even if we didn't zoom so notify the client. + notifyTransformedContentsSizeChanged(); + notifyTransformedScrollChanged(); + + if (!needsLayout) { + // The visible tiles for scroll must be up-to-date before we blit since we are not performing a layout. + m_backingStore->d->updateTilesForScrollOrNotRenderedRegion(); + } + + if (ensureFocusElementVisible) + ensureContentVisible(!newVisibleRectContainsOldVisibleRect); + + if (needsLayout) { + m_backingStore->d->resetTiles(true); + m_backingStore->d->updateTiles(false /* updateVisible */, false /* immediate */); + } + + // If we need layout then render and blit, otherwise just blit as our viewport has changed. + m_backingStore->d->resumeScreenAndBackingStoreUpdates(needsLayout ? BackingStore::RenderAndBlit : BackingStore::Blit); + } else if (ensureFocusElementVisible) + ensureContentVisible(!newVisibleRectContainsOldVisibleRect); +} + +void WebPage::setDefaultLayoutSize(int width, int height) +{ + IntSize size(width, height); + d->setDefaultLayoutSize(size); +} + +void WebPagePrivate::setDefaultLayoutSize(const IntSize& size) +{ + if (size == m_defaultLayoutSize) + return; + + IntSize screenSize = Platform::Graphics::Screen::size(); + ASSERT(size.width() <= screenSize.width() && size.height() <= screenSize.height()); + m_defaultLayoutSize = size.expandedTo(minimumLayoutSize).shrunkTo(screenSize); + + bool needsLayout = setViewMode(viewMode()); + if (needsLayout) { + setNeedsLayout(); + if (!isLoading()) + requestLayoutIfNeeded(); + } +} + +bool WebPage::mouseEvent(const Platform::MouseEvent& mouseEvent, bool* wheelDeltaAccepted) +{ + if (!d->m_mainFrame->view()) + return false; + + PluginView* pluginView = d->m_fullScreenPluginView.get(); + if (pluginView) + return d->dispatchMouseEventToFullScreenPlugin(pluginView, mouseEvent); + + if (mouseEvent.type() == Platform::MouseEvent::MouseAborted) { + d->m_mainFrame->eventHandler()->setMousePressed(false); + return false; + } + + d->m_pluginMayOpenNewTab = true; + + d->m_lastUserEventTimestamp = currentTime(); + int clickCount = (d->m_selectionHandler->isSelectionActive() || mouseEvent.type() != Platform::MouseEvent::MouseMove) ? 1 : 0; + + // Set the button type. + MouseButton buttonType = NoButton; + if (mouseEvent.isLeftButton()) + buttonType = LeftButton; + else if (mouseEvent.isRightButton()) + buttonType = RightButton; + else if (mouseEvent.isMiddleButton()) + buttonType = MiddleButton; + + // Create our event. + PlatformMouseEvent platformMouseEvent(d->mapFromTransformed(mouseEvent.position()), + d->mapFromTransformed(mouseEvent.screenPosition()), + toWebCoreMouseEventType(mouseEvent.type()), clickCount, buttonType, PointingDevice); + d->m_lastMouseEvent = platformMouseEvent; + bool success = d->handleMouseEvent(platformMouseEvent); + + if (mouseEvent.wheelTicks()) { + PlatformWheelEvent wheelEvent(d->mapFromTransformed(mouseEvent.position()), + d->mapFromTransformed(mouseEvent.screenPosition()), + 0, -mouseEvent.wheelDelta(), + 0, -mouseEvent.wheelTicks(), + ScrollByPixelWheelEvent, + false /* shiftKey */, false /* ctrlKey */, + false /* altKey */, false /* metaKey */); + if (wheelDeltaAccepted) + *wheelDeltaAccepted = d->handleWheelEvent(wheelEvent); + } else if (wheelDeltaAccepted) + *wheelDeltaAccepted = false; + + return success; +} + +bool WebPagePrivate::dispatchMouseEventToFullScreenPlugin(PluginView* plugin, const Platform::MouseEvent& event) +{ + NPEvent npEvent; + NPMouseEvent mouseEvent; + + mouseEvent.x = event.screenPosition().x(); + mouseEvent.y = event.screenPosition().y(); + + switch (event.type()) { + case Platform::MouseEvent::MouseButtonDown: + mouseEvent.type = MOUSE_BUTTON_DOWN; + m_pluginMouseButtonPressed = true; + break; + case Platform::MouseEvent::MouseButtonUp: + mouseEvent.type = MOUSE_BUTTON_UP; + m_pluginMouseButtonPressed = false; + break; + case Platform::MouseEvent::MouseMove: + mouseEvent.type = MOUSE_MOTION; + break; + default: + return false; + } + + mouseEvent.flags = 0; + mouseEvent.button = m_pluginMouseButtonPressed; + + npEvent.type = NP_MouseEvent; + npEvent.data = &mouseEvent; + + return plugin->dispatchFullScreenNPEvent(npEvent); +} + +bool WebPagePrivate::handleMouseEvent(PlatformMouseEvent& mouseEvent) +{ + EventHandler* eventHandler = m_mainFrame->eventHandler(); + + if (mouseEvent.eventType() == MouseEventMoved) + return eventHandler->mouseMoved(mouseEvent); + + if (mouseEvent.eventType() == MouseEventScroll) + return true; + + Node* node = 0; + if (mouseEvent.inputMethod() == TouchScreen) { + const FatFingersResult lastFatFingersResult = m_touchEventHandler->lastFatFingersResult(); + + // Fat fingers can deal with shadow content. + node = lastFatFingersResult.node(FatFingersResult::ShadowContentNotAllowed); + } + + if (!node) { + HitTestResult result = eventHandler->hitTestResultAtPoint(mapFromViewportToContents(mouseEvent.pos()), false /*allowShadowContent*/); + node = result.innerNode(); + } + + if (mouseEvent.eventType() == MouseEventPressed) { + if (m_inputHandler->willOpenPopupForNode(node)) { + // Do not allow any human generated mouse or keyboard events to select <option>s in the list box + // because we use a pop up dialog to handle the actual selections. This prevents options from + // being selected prior to displaying the pop up dialog. The contents of the listbox are for + // display only. + // + // FIXME: We explicitly do not forward this event to WebCore so as to preserve symmetry with + // the MouseEventReleased handling (below). This has the side-effect that mousedown events + // are not fired for human generated mouse press events. See RIM Bug #1579. + + // We do focus <select>/<option> on mouse down so that a Focus event is fired and have the + // element painted in its focus state on repaint. + ASSERT(node->isElementNode()); + if (node->isElementNode()) { + Element* element = static_cast<Element*>(node); + element->focus(); + } + } else + eventHandler->handleMousePressEvent(mouseEvent); + } else if (mouseEvent.eventType() == MouseEventReleased) { + // FIXME: For <select> and <options> elements, we explicitly do not forward this event to WebCore so + // as to preserve symmetry with the MouseEventPressed handling (above). This has the side-effect that + // mouseup events are not fired on such elements for human generated mouse release events. See RIM Bug #1579. + if (!m_inputHandler->didNodeOpenPopup(node)) + eventHandler->handleMouseReleaseEvent(mouseEvent); + } + + return true; +} + +bool WebPagePrivate::handleWheelEvent(PlatformWheelEvent& wheelEvent) +{ + return m_mainFrame->eventHandler()->handleWheelEvent(wheelEvent); +} + +bool WebPage::touchEvent(const Platform::TouchEvent& event) +{ +#if DEBUG_TOUCH_EVENTS + switch (event.m_type) { + case Platform::TouchEvent::TouchEnd: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent Touch End"); + break; + case Platform::TouchEvent::TouchStart: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent Touch Start"); + break; + case Platform::TouchEvent::TouchMove: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent Touch Move"); + break; + case Platform::TouchEvent::TouchCancel: + Platform::log(Platform::LogLevelCritical, "WebPage::touchCancel Touch Cancel"); + break; + } + + for (unsigned i = 0; i < event.m_points.size(); i++) { + switch (event.m_points[i].m_state) { + case Platform::TouchPoint::TouchPressed: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent %d Touch Pressed (%d, %d)", event.m_points[i].m_id, event.m_points[i].m_pos.x(), event.m_points[i].m_pos.y()); + break; + case Platform::TouchPoint::TouchReleased: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent %d Touch Released (%d, %d)", event.m_points[i].m_id, event.m_points[i].m_pos.x(), event.m_points[i].m_pos.y()); + break; + case Platform::TouchPoint::TouchMoved: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent %d Touch Moved (%d, %d)", event.m_points[i].m_id, event.m_points[i].m_pos.x(), event.m_points[i].m_pos.y()); + break; + case Platform::TouchPoint::TouchStationary: + Platform::log(Platform::LogLevelCritical, "WebPage::touchEvent %d Touch Stationary (%d, %d)", event.m_points[i].m_id, event.m_points[i].m_pos.x(), event.m_points[i].m_pos.y()); + break; + } + } +#endif + +#if ENABLE(TOUCH_EVENTS) + PluginView* pluginView = d->m_fullScreenPluginView.get(); + if (pluginView) + return d->dispatchTouchEventToFullScreenPlugin(pluginView, event); + + if (!d->m_mainFrame) + return false; + + Platform::TouchEvent tEvent = event; + for (unsigned i = 0; i < event.m_points.size(); i++) { + tEvent.m_points[i].m_pos = d->mapFromTransformed(tEvent.m_points[i].m_pos); + tEvent.m_points[i].m_screenPos = d->mapFromTransformed(tEvent.m_points[i].m_screenPos); + } + + Platform::Gesture tapGesture; + if (event.hasGesture(Platform::Gesture::SingleTap)) + d->m_pluginMayOpenNewTab = true; + else if (tEvent.m_type == Platform::TouchEvent::TouchStart || tEvent.m_type == Platform::TouchEvent::TouchCancel) + d->m_pluginMayOpenNewTab = false; + + bool handled = false; + + if (d->m_needTouchEvents && !event.hasGesture(Platform::Gesture::Injected)) + handled = d->m_mainFrame->eventHandler()->handleTouchEvent(PlatformTouchEvent(&tEvent)); + + // Unpress mouse if touch end is consumed by a JavaScript touch handler, otherwise the mouse state will remain pressed + // which could either mess up the internal mouse state or start text selection on the next mouse move/down. + if (tEvent.m_type == Platform::TouchEvent::TouchEnd && handled && d->m_mainFrame->eventHandler()->mousePressed()) + d->m_touchEventHandler->touchEventCancel(); + + if (d->m_preventDefaultOnTouchStart) { + if (tEvent.m_type == Platform::TouchEvent::TouchEnd || tEvent.m_type == Platform::TouchEvent::TouchCancel) + d->m_preventDefaultOnTouchStart = false; + return true; + } + + if (handled) { + if (tEvent.m_type == Platform::TouchEvent::TouchStart) + d->m_preventDefaultOnTouchStart = true; + return true; + } + + if (event.hasGesture(Platform::Gesture::TouchHold)) + d->m_touchEventHandler->touchHoldEvent(); +#endif + + return false; +} + +void WebPage::setScrollOriginPoint(const Platform::IntPoint& point) +{ + Platform::IntPoint untransformedPoint = d->mapFromTransformed(point); + d->setScrollOriginPoint(untransformedPoint); +} + +void WebPagePrivate::setScrollOriginPoint(const Platform::IntPoint& point) +{ + m_inRegionScrollStartingNode = 0; + + if (!m_hasInRegionScrollableAreas) + return; + + m_client->notifyInRegionScrollingStartingPointChanged(inRegionScrollableAreasForPoint(point)); +} + +bool WebPagePrivate::dispatchTouchEventToFullScreenPlugin(PluginView* plugin, const Platform::TouchEvent& event) +{ + NPTouchEvent npTouchEvent; + + if (event.hasGesture(Platform::Gesture::DoubleTap)) + npTouchEvent.type = TOUCH_EVENT_DOUBLETAP; + else if (event.hasGesture(Platform::Gesture::TouchHold)) + npTouchEvent.type = TOUCH_EVENT_TOUCHHOLD; + else { + switch (event.m_type) { + case Platform::TouchEvent::TouchStart: + npTouchEvent.type = TOUCH_EVENT_START; + break; + case Platform::TouchEvent::TouchEnd: + npTouchEvent.type = TOUCH_EVENT_END; + break; + case Platform::TouchEvent::TouchMove: + npTouchEvent.type = TOUCH_EVENT_MOVE; + break; + case Platform::TouchEvent::TouchCancel: + npTouchEvent.type = TOUCH_EVENT_CANCEL; + break; + default: + return false; + } + } + + npTouchEvent.points = 0; + npTouchEvent.size = event.m_points.size(); + if (npTouchEvent.size) { + npTouchEvent.points = new NPTouchPoint[npTouchEvent.size]; + for (int i = 0; i < npTouchEvent.size; i++) { + npTouchEvent.points[i].touchId = event.m_points[i].m_id; + npTouchEvent.points[i].clientX = event.m_points[i].m_screenPos.x(); + npTouchEvent.points[i].clientY = event.m_points[i].m_screenPos.y(); + npTouchEvent.points[i].screenX = event.m_points[i].m_screenPos.x(); + npTouchEvent.points[i].screenY = event.m_points[i].m_screenPos.y(); + npTouchEvent.points[i].pageX = event.m_points[i].m_pos.x(); + npTouchEvent.points[i].pageY = event.m_points[i].m_pos.y(); + } + } + + NPEvent npEvent; + npEvent.type = NP_TouchEvent; + npEvent.data = &npTouchEvent; + + bool handled = plugin->dispatchFullScreenNPEvent(npEvent); + + if (npTouchEvent.type == TOUCH_EVENT_DOUBLETAP && !handled) { + // Send Touch Up if double tap not consumed. + npTouchEvent.type = TOUCH_EVENT_END; + npEvent.data = &npTouchEvent; + handled = plugin->dispatchFullScreenNPEvent(npEvent); + } + delete[] npTouchEvent.points; + return handled; +} + +bool WebPage::touchPointAsMouseEvent(const Platform::TouchPoint& point) +{ + PluginView* pluginView = d->m_fullScreenPluginView.get(); + if (pluginView) + return d->dispatchTouchPointAsMouseEventToFullScreenPlugin(pluginView, point); + + d->m_lastUserEventTimestamp = currentTime(); + + Platform::TouchPoint tPoint = point; + tPoint.m_pos = d->mapFromTransformed(tPoint.m_pos); + tPoint.m_screenPos = d->mapFromTransformed(tPoint.m_screenPos); + + return d->m_touchEventHandler->handleTouchPoint(tPoint); +} + +bool WebPagePrivate::dispatchTouchPointAsMouseEventToFullScreenPlugin(PluginView* pluginView, const Platform::TouchPoint& point) +{ + NPEvent npEvent; + NPMouseEvent mouse; + + switch (point.m_state) { + case Platform::TouchPoint::TouchPressed: + mouse.type = MOUSE_BUTTON_DOWN; + break; + case Platform::TouchPoint::TouchReleased: + mouse.type = MOUSE_BUTTON_UP; + break; + case Platform::TouchPoint::TouchMoved: + mouse.type = MOUSE_MOTION; + break; + case Platform::TouchPoint::TouchStationary: + return false; + } + + mouse.x = point.m_screenPos.x(); + mouse.y = point.m_screenPos.y(); + mouse.button = mouse.type != MOUSE_BUTTON_UP; + mouse.flags = 0; + npEvent.type = NP_MouseEvent; + npEvent.data = &mouse; + + return pluginView->dispatchFullScreenNPEvent(npEvent); +} + +void WebPage::touchEventCancel() +{ + d->m_pluginMayOpenNewTab = false; + d->m_touchEventHandler->touchEventCancel(); +} + +void WebPage::touchEventCancelAndClearFocusedNode() +{ + d->m_touchEventHandler->touchEventCancelAndClearFocusedNode(); +} + +Frame* WebPagePrivate::focusedOrMainFrame() const +{ + return m_page->focusController()->focusedOrMainFrame(); +} + +void WebPagePrivate::clearFocusNode() +{ + Frame* frame = focusedOrMainFrame(); + if (!frame) + return; + ASSERT(frame->document()); + + if (frame->document()->focusedNode()) + frame->page()->focusController()->setFocusedNode(0, frame); +} + +bool WebPagePrivate::scrollNodeRecursively(Node* node, const IntSize& delta) +{ + if (delta.isZero()) + return true; + + if (!node) + return false; + + RenderObject* renderer = node->renderer(); + if (!renderer) + return false; + + FrameView* view = renderer->view()->frameView(); + if (!view) + return false; + + // Try scrolling the renderer. + if (scrollRenderer(renderer, delta)) + return true; + + // We've hit the page, don't scroll it and return false. + if (view == m_mainFrame->view()) + return false; + + // Try scrolling the FrameView. + if (canScrollInnerFrame(view->frame())) { + IntSize viewDelta = delta; + IntPoint newViewOffset = view->scrollPosition(); + IntPoint maxViewOffset = view->maximumScrollPosition(); + adjustScrollDelta(maxViewOffset, newViewOffset, viewDelta); + + if (!viewDelta.isZero()) { + view->setCanBlitOnScroll(false); + + BackingStoreClient* backingStoreClient = backingStoreClientForFrame(view->frame()); + if (backingStoreClient) { + backingStoreClient->setIsClientGeneratedScroll(true); + backingStoreClient->setIsScrollNotificationSuppressed(true); + } + + m_inRegionScrollStartingNode = view->frame()->document(); + + view->scrollBy(viewDelta); + + if (backingStoreClient) { + backingStoreClient->setIsClientGeneratedScroll(false); + backingStoreClient->setIsScrollNotificationSuppressed(false); + } + + return true; + } + } + + // Try scrolling the node of the enclosing frame. + Frame* frame = node->document()->frame(); + if (frame) { + Node* ownerNode = frame->ownerElement(); + if (scrollNodeRecursively(ownerNode, delta)) + return true; + } + + return false; +} + +void WebPagePrivate::adjustScrollDelta(const IntPoint& maxOffset, const IntPoint& currentOffset, IntSize& delta) const +{ + if (currentOffset.x() + delta.width() > maxOffset.x()) + delta.setWidth(min(maxOffset.x() - currentOffset.x(), delta.width())); + + if (currentOffset.x() + delta.width() < 0) + delta.setWidth(max(-currentOffset.x(), delta.width())); + + if (currentOffset.y() + delta.height() > maxOffset.y()) + delta.setHeight(min(maxOffset.y() - currentOffset.y(), delta.height())); + + if (currentOffset.y() + delta.height() < 0) + delta.setHeight(max(-currentOffset.y(), delta.height())); +} + +static Node* enclosingLayerNode(RenderLayer*); + +bool WebPagePrivate::scrollRenderer(RenderObject* renderer, const IntSize& delta) +{ + RenderLayer* layer = renderer->enclosingLayer(); + if (!layer) + return false; + + // Try to scroll layer. + bool restrictedByLineClamp = false; + if (renderer->parent()) + restrictedByLineClamp = !renderer->parent()->style()->lineClamp().isNone(); + + if (renderer->hasOverflowClip() && !restrictedByLineClamp) { + IntSize layerDelta = delta; + IntPoint maxOffset(layer->scrollWidth() - layer->renderBox()->clientWidth(), layer->scrollHeight() - layer->renderBox()->clientHeight()); + IntPoint currentOffset(layer->scrollXOffset(), layer->scrollYOffset()); + adjustScrollDelta(maxOffset, currentOffset, layerDelta); + if (!layerDelta.isZero()) { + m_inRegionScrollStartingNode = enclosingLayerNode(layer); + IntPoint newOffset = currentOffset + layerDelta; + layer->scrollToOffset(newOffset.x(), newOffset.y()); + renderer->repaint(true); + return true; + } + } + + while (layer = layer->parent()) { + if (canScrollRenderBox(layer->renderBox())) + return scrollRenderer(layer->renderBox(), delta); + } + + return false; +} + +static void handleScrolling(unsigned short character, WebPagePrivate* scroller) +{ + const int scrollFactor = 20; + int dx = 0, dy = 0; + switch (character) { + case KEYCODE_LEFT: + dx = -scrollFactor; + break; + case KEYCODE_RIGHT: + dx = scrollFactor; + break; + case KEYCODE_UP: + dy = -scrollFactor; + break; + case KEYCODE_DOWN: + dy = scrollFactor; + break; + case KEYCODE_PG_UP: + ASSERT(scroller); + dy = scrollFactor - scroller->actualVisibleSize().height(); + break; + case KEYCODE_PG_DOWN: + ASSERT(scroller); + dy = scroller->actualVisibleSize().height() - scrollFactor; + break; + } + + if (dx || dy) { + // Don't use the scrollBy function because it triggers the scroll as originating from BlackBerry + // but then it expects a separate invalidate which isn't sent in this case. + ASSERT(scroller && scroller->m_mainFrame && scroller->m_mainFrame->view()); + IntPoint pos(scroller->scrollPosition() + IntSize(dx, dy)); + + // Prevent over scrolling for arrows and Page up/down. + if (pos.x() < 0) + pos.setX(0); + if (pos.y() < 0) + pos.setY(0); + if (pos.x() + scroller->actualVisibleSize().width() > scroller->contentsSize().width()) + pos.setX(scroller->contentsSize().width() - scroller->actualVisibleSize().width()); + if (pos.y() + scroller->actualVisibleSize().height() > scroller->contentsSize().height()) + pos.setY(scroller->contentsSize().height() - scroller->actualVisibleSize().height()); + + scroller->m_mainFrame->view()->setScrollPosition(pos); + scroller->m_client->scrollChanged(pos); + } +} + +bool WebPage::keyEvent(const Platform::KeyboardEvent& keyboardEvent) +{ + if (!d->m_mainFrame->view()) + return false; + + ASSERT(d->m_page->focusController()); + + bool handled = d->m_inputHandler->handleKeyboardInput(keyboardEvent); + + if (!handled && keyboardEvent.type() == Platform::KeyboardEvent::KeyDown && !d->m_inputHandler->isInputMode()) { + IntPoint previousPos = d->scrollPosition(); + handleScrolling(keyboardEvent.character(), d); + handled = previousPos != d->scrollPosition(); + } + + return handled; +} + +bool WebPage::deleteTextRelativeToCursor(unsigned int leftOffset, unsigned int rightOffset) +{ + return d->m_inputHandler->deleteTextRelativeToCursor(leftOffset, rightOffset); +} + +spannable_string_t* WebPage::selectedText(int32_t flags) +{ + return d->m_inputHandler->selectedText(flags); +} + +spannable_string_t* WebPage::textBeforeCursor(int32_t length, int32_t flags) +{ + return d->m_inputHandler->textBeforeCursor(length, flags); +} + +spannable_string_t* WebPage::textAfterCursor(int32_t length, int32_t flags) +{ + return d->m_inputHandler->textAfterCursor(length, flags); +} + +extracted_text_t* WebPage::extractedTextRequest(extracted_text_request_t* request, int32_t flags) +{ + return d->m_inputHandler->extractedTextRequest(request, flags); +} + +int32_t WebPage::setComposingRegion(int32_t start, int32_t end) +{ + return d->m_inputHandler->setComposingRegion(start, end); +} + +int32_t WebPage::finishComposition() +{ + return d->m_inputHandler->finishComposition(); +} + +int32_t WebPage::setComposingText(spannable_string_t* spannableString, int32_t relativeCursorPosition) +{ + return d->m_inputHandler->setComposingText(spannableString, relativeCursorPosition); +} + +int32_t WebPage::commitText(spannable_string_t* spannableString, int32_t relativeCursorPosition) +{ + return d->m_inputHandler->commitText(spannableString, relativeCursorPosition); +} + +void WebPage::spellCheckingEnabled(bool enabled) +{ + static_cast<EditorClientBlackBerry*>(d->m_page->editorClient())->enableSpellChecking(enabled); +} + +void WebPage::selectionCancelled() +{ + d->m_selectionHandler->cancelSelection(); +} + +bool WebPage::selectionContains(const Platform::IntPoint& point) +{ + return d->m_selectionHandler->selectionContains(d->mapFromTransformed(point)); +} + +WebString WebPage::title() const +{ + if (d->m_mainFrame->document()) + return d->m_mainFrame->loader()->documentLoader()->title().string(); + return WebString(); +} + +WebString WebPage::selectedText() const +{ + return d->m_selectionHandler->selectedText(); +} + +WebString WebPage::cutSelectedText() +{ + WebString selectedText = d->m_selectionHandler->selectedText(); + if (!selectedText.isEmpty()) + d->m_inputHandler->deleteSelection(); + return selectedText; +} + +void WebPage::insertText(const WebString& string) +{ + d->m_inputHandler->insertText(string); +} + +void WebPage::clearCurrentInputField() +{ + d->m_inputHandler->clearField(); +} + +void WebPage::cut() +{ + d->m_inputHandler->cut(); +} + +void WebPage::copy() +{ + d->m_inputHandler->copy(); +} + +void WebPage::paste() +{ + d->m_inputHandler->paste(); +} + +void WebPage::setSelection(const Platform::IntPoint& startPoint, const Platform::IntPoint& endPoint) +{ + // Transform this events coordinates to webkit content coordinates. + // FIXME: Don't transform the sentinel, because it may be transformed to a floating number + // which could be rounded to 0 or other numbers. This workaround should be removed after + // the error of roundUntransformedPoint() is fixed. + bool invalidPoint = IntPoint(startPoint) == DOMSupport::InvalidPoint; + IntPoint start = invalidPoint ? DOMSupport::InvalidPoint : d->mapFromTransformed(startPoint); + invalidPoint = IntPoint(endPoint) == DOMSupport::InvalidPoint; + IntPoint end = invalidPoint ? DOMSupport::InvalidPoint : d->mapFromTransformed(endPoint); + + d->m_selectionHandler->setSelection(start, end); +} + +void WebPage::setCaretPosition(const Platform::IntPoint& position) +{ + // Handled by selection handler as it's point based. + // Transform this events coordinates to webkit content coordinates. + d->m_selectionHandler->setCaretPosition(d->mapFromTransformed(position)); +} + +void WebPage::selectAtPoint(const Platform::IntPoint& location) +{ + // Transform this events coordinates to webkit content coordinates if it + // is not the sentinel value. + IntPoint selectionLocation = + IntPoint(location) == DOMSupport::InvalidPoint ? + DOMSupport::InvalidPoint : + d->mapFromTransformed(location); + + d->m_selectionHandler->selectAtPoint(selectionLocation); +} + +// Returned scroll position is in transformed coordinates. +Platform::IntPoint WebPage::scrollPosition() const +{ + return d->transformedScrollPosition(); +} + +// Setting the scroll position is in transformed coordinates. +void WebPage::setScrollPosition(const Platform::IntPoint& point) +{ + if (d->transformedPointEqualsUntransformedPoint(point, d->scrollPosition())) + return; + + // If the user recently performed an event, this new scroll position + // could possibly be a result of that. Or not, this is just a heuristic. + if (currentTime() - d->m_lastUserEventTimestamp < manualScrollInterval) + d->m_userPerformedManualScroll = true; + + d->m_backingStoreClient->setIsClientGeneratedScroll(true); + d->m_mainFrame->view()->setCanOverscroll(true); + d->setScrollPosition(d->mapFromTransformed(point)); + d->m_mainFrame->view()->setCanOverscroll(false); + d->m_backingStoreClient->setIsClientGeneratedScroll(false); +} + +WebString WebPage::textEncoding() +{ + Frame* frame = d->focusedOrMainFrame(); + if (!frame) + return ""; + + Document* document = frame->document(); + if (!document) + return ""; + + return document->loader()->writer()->encoding(); +} + +WebString WebPage::forcedTextEncoding() +{ + Frame* frame = d->focusedOrMainFrame(); + if (!frame) + return ""; + + Document* document = frame->document(); + if (!document) + return ""; + + return document->loader()->overrideEncoding(); +} + +void WebPage::setForcedTextEncoding(const char* encoding) +{ + if (encoding && d->focusedOrMainFrame() && d->focusedOrMainFrame()->loader() && d->focusedOrMainFrame()->loader()) + return d->focusedOrMainFrame()->loader()->reloadWithOverrideEncoding(encoding); +} + +// FIXME: Move to DOMSupport. +bool WebPagePrivate::canScrollInnerFrame(Frame* frame) const +{ + if (!frame || !frame->view()) + return false; + + // Not having an owner element means that we are on the mainframe. + if (!frame->ownerElement()) + return false; + + ASSERT(frame != m_mainFrame); + + IntSize visibleSize = frame->view()->visibleContentRect().size(); + IntSize contentsSize = frame->view()->contentsSize(); + + bool canBeScrolled = contentsSize.height() > visibleSize.height() || contentsSize.width() > visibleSize.width(); + + // Lets also consider the 'overflow-{x,y} property set directly to the {i}frame tag. + return canBeScrolled && (frame->ownerElement()->scrollingMode() != ScrollbarAlwaysOff); +} + +// The RenderBox::canbeScrolledAndHasScrollableArea method returns true for the +// following scenario, for example: +// (1) a div that has a vertical overflow but no horizontal overflow +// with overflow-y: hidden and overflow-x: auto set. +// The version below fixes it. +// FIXME: Fix RenderBox::canBeScrolledAndHasScrollableArea method instead. +bool WebPagePrivate::canScrollRenderBox(RenderBox* box) +{ + if (!box || !box->hasOverflowClip()) + return false; + + if (box->scrollsOverflowX() && (box->scrollWidth() != box->clientWidth()) + || box->scrollsOverflowY() && (box->scrollHeight() != box->clientHeight())) + return true; + + Node* node = box->node(); + return node && (node->rendererIsEditable() || node->isDocumentNode()); +} + +static RenderLayer* parentLayer(RenderLayer* layer) +{ + ASSERT(layer); + + if (layer->parent()) + return layer->parent(); + + RenderObject* renderer = layer->renderer(); + if (renderer->document() && renderer->document()->ownerElement() && renderer->document()->ownerElement()->renderer()) + return renderer->document()->ownerElement()->renderer()->enclosingLayer(); + + return 0; +} + +// FIXME: Make RenderLayer::enclosingElement public so this one can be removed. +static Node* enclosingLayerNode(RenderLayer* layer) +{ + for (RenderObject* r = layer->renderer(); r; r = r->parent()) { + if (Node* e = r->node()) + return e; + } + ASSERT_NOT_REACHED(); + return 0; +} + +static void pushBackInRegionScrollable(std::vector<Platform::ScrollViewBase>& vector, InRegionScrollableArea scroller, WebPagePrivate* webPage) +{ + ASSERT(webPage); + ASSERT(!scroller.isNull()); + + scroller.setCanPropagateScrollingToEnclosingScrollable(!isNonRenderViewFixedPositionedContainer(scroller.layer())); + vector.push_back(scroller); + if (vector.size() == 1) { + // FIXME: Use RenderLayer::renderBox()->node() instead? + webPage->m_inRegionScrollStartingNode = enclosingLayerNode(scroller.layer()); + } +} + +std::vector<Platform::ScrollViewBase> WebPagePrivate::inRegionScrollableAreasForPoint(const Platform::IntPoint& point) +{ + std::vector<Platform::ScrollViewBase> validReturn; + std::vector<Platform::ScrollViewBase> emptyReturn; + + HitTestResult result = m_mainFrame->eventHandler()->hitTestResultAtPoint(mapFromViewportToContents(point), false /*allowShadowContent*/); + Node* node = result.innerNonSharedNode(); + if (!node) + return emptyReturn; + + RenderObject* renderer = node->renderer(); + // FIXME: Validate with elements with visibility:hidden. + if (!renderer) + return emptyReturn; + + RenderLayer* layer = renderer->enclosingLayer(); + + do { + RenderObject* renderer = layer->renderer(); + + if (renderer->isRenderView()) { + if (RenderView* renderView = toRenderView(renderer)) { + FrameView* view = renderView->frameView(); + if (!view) + return emptyReturn; + + if (canScrollInnerFrame(view->frame())) { + pushBackInRegionScrollable(validReturn, InRegionScrollableArea(this, layer), this); + continue; + } + } + } else if (canScrollRenderBox(layer->renderBox())) { + pushBackInRegionScrollable(validReturn, InRegionScrollableArea(this, layer), this); + continue; + } + + // If we run into a fix positioned layer, set the last scrollable in-region object + // as not able to propagate scroll to its parent scrollable. + if (isNonRenderViewFixedPositionedContainer(layer) && validReturn.size()) { + Platform::ScrollViewBase& end = validReturn.back(); + end.setCanPropagateScrollingToEnclosingScrollable(false); + } + + } while (layer = parentLayer(layer)); + + if (validReturn.empty()) + return emptyReturn; + + return validReturn; +} + +BackingStore* WebPage::backingStore() const +{ + return d->m_backingStore; +} + +bool WebPage::zoomToFit() +{ + if (d->contentsSize().isEmpty() || !d->isUserScalable()) + return false; + + d->m_userPerformedManualZoom = true; + + // TODO: We may need to use (0,0) as the anchor point when textReflow is enabled. + // IF the minimum font size is ginormous, we may still want the scroll position to be 0,0. + return d->zoomAboutPoint(d->zoomToFitScale(), d->centerOfVisibleContentsRect()); +} + +void WebPagePrivate::setTextReflowAnchorPoint(const Platform::IntPoint& focalPoint) +{ + // Should only be invoked when text reflow is enabled. + ASSERT(m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabled); + + m_currentPinchZoomNode = bestNodeForZoomUnderPoint(focalPoint); + if (!m_currentPinchZoomNode) + return; + + IntRect nodeRect = rectForNode(m_currentPinchZoomNode.get()); + m_anchorInNodeRectRatio.set(static_cast<float>(mapFromTransformed(focalPoint).x() - nodeRect.x()) / nodeRect.width(), + static_cast<float>(mapFromTransformed(focalPoint).y() - nodeRect.y()) / nodeRect.height()); +} + +bool WebPage::pinchZoomAboutPoint(double scale, int x, int y) +{ + IntPoint anchor(x, y); + d->m_userPerformedManualZoom = true; + d->m_userPerformedManualScroll = true; + + if (d->m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabled) { + d->setTextReflowAnchorPoint(anchor); + // Theoretically, d->nodeForZoomUnderPoint(anchor) can return null. + if (!d->m_currentPinchZoomNode) + return false; + } + + return d->zoomAboutPoint(scale, d->mapFromTransformed(anchor)); +} + +#if ENABLE(VIEWPORT_REFLOW) +void WebPagePrivate::toggleTextReflowIfEnabledForBlockZoomOnly(bool shouldEnableTextReflow) +{ + if (m_webPage->settings()->textReflowMode() == WebSettings::TextReflowEnabledOnlyForBlockZoom) + m_page->settings()->setTextReflowEnabled(shouldEnableTextReflow); +} +#endif + +bool WebPage::blockZoom(int x, int y) +{ + if (!d->m_mainFrame->view() || !d->isUserScalable()) + return false; + + Node* node = d->bestNodeForZoomUnderPoint(IntPoint(x, y)); + if (!node) + return false; + + IntRect nodeRect = d->rectForNode(node); + IntRect blockRect; + bool endOfBlockZoomMode = d->compareNodesForBlockZoom(d->m_currentBlockZoomAdjustedNode.get(), node); + const double oldScale = d->m_transformationMatrix->m11(); + double newScale = 0; + const double margin = endOfBlockZoomMode ? 0 : blockZoomMargin * 2 * oldScale; + bool isFirstZoom = false; + + if (endOfBlockZoomMode) { + // End of block zoom mode + IntRect rect = d->blockZoomRectForNode(node); + blockRect = IntRect(0, rect.y(), d->transformedContentsSize().width(), d->transformedContentsSize().height() - rect.y()); + d->m_shouldReflowBlock = false; + } else { + // Start/continue block zoom mode + Node* tempBlockZoomAdjustedNode = d->m_currentBlockZoomAdjustedNode.get(); + blockRect = d->blockZoomRectForNode(node); + + // Don't use a block if it is too close to the size of the actual contents. + // We allow this for images only so that they can be zoomed tight to the screen. + if (!node->hasTagName(HTMLNames::imgTag)) { + IntRect tRect = d->mapFromTransformed(blockRect); + int blockArea = tRect.width() * tRect.height(); + int pageArea = d->contentsSize().width() * d->contentsSize().height(); + double blockToPageRatio = static_cast<double>(1 - blockArea / pageArea); + if (blockToPageRatio < minimumExpandingRatio) { + // Restore old adjust node because zoom was canceled. + d->m_currentBlockZoomAdjustedNode = tempBlockZoomAdjustedNode; + return false; + } + } + + if (blockRect.isEmpty() || !blockRect.width() || !blockRect.height()) + return false; + + if (!d->m_currentBlockZoomNode.get()) + isFirstZoom = true; + + d->m_currentBlockZoomNode = node; + d->m_shouldReflowBlock = true; + } + + newScale = std::min(d->newScaleForBlockZoomRect(blockRect, oldScale, margin), d->maxBlockZoomScale()); + newScale = std::max(newScale, minimumScale()); + +#if DEBUG_BLOCK_ZOOM + // Render the double tap point for visual reference. + IntRect renderRect(x, y, 1, 1); + renderRect = d->mapFromTransformedContentsToTransformedViewport(renderRect); + IntSize viewportSize = d->transformedViewportSize(); + renderRect.intersect(IntRect(0, 0, viewportSize.width(), viewportSize.height())); + d->m_backingStore->d->clearWindow(renderRect, 0, 0, 0); + d->m_backingStore->d->invalidateWindow(renderRect); + + // Uncomment this to return in order to see the blocks being selected. + // d->m_client->zoomChanged(isMinZoomed(), isMaxZoomed(), isAtInitialZoom(), currentZoomLevel()); + // return true; +#endif + +#if ENABLE(VIEWPORT_REFLOW) + // If reflowing, adjust the reflow-width of text node to make sure the font is a reasonable size. + if (d->m_currentBlockZoomNode && d->m_shouldReflowBlock && settings()->textReflowMode() != WebSettings::TextReflowDisabled) { + RenderObject* renderer = d->m_currentBlockZoomNode->renderer(); + if (renderer && renderer->isText()) { + double newFontSize = renderer->style()->fontSize() * newScale; + if (newFontSize < d->m_webSettings->defaultFontSize()) { + newScale = std::min(static_cast<double>(d->m_webSettings->defaultFontSize()) / renderer->style()->fontSize(), d->maxBlockZoomScale()); + newScale = std::max(newScale, minimumScale()); + } + blockRect.setWidth(oldScale * static_cast<double>(d->transformedActualVisibleSize().width()) / newScale); + // Re-calculate the scale here to take in to account the margin. + newScale = std::min(d->newScaleForBlockZoomRect(blockRect, oldScale, margin), d->maxBlockZoomScale()); + newScale = std::max(newScale, minimumScale()); // Still, it's not allowed to be smaller than minimum scale. + } + } +#endif + + // Align the zoomed block in the screen. + double newBlockHeight = d->mapFromTransformed(blockRect).height(); + double newBlockWidth = d->mapFromTransformed(blockRect).width(); + double scaledViewportWidth = static_cast<double>(d->actualVisibleSize().width()) * oldScale / newScale; + double scaledViewportHeight = static_cast<double>(d->actualVisibleSize().height()) * oldScale / newScale; + double dx = std::max(0.0, (scaledViewportWidth - newBlockWidth) / 2.0); + double dy = std::max(0.0, (scaledViewportHeight - newBlockHeight) / 2.0); + + RenderObject* renderer = d->m_currentBlockZoomAdjustedNode->renderer(); + FloatPoint anchor; + FloatPoint topLeftPoint(d->mapFromTransformed(blockRect).location()); + if (renderer && renderer->isText()) { + ETextAlign textAlign = renderer->style()->textAlign(); + switch (textAlign) { + case CENTER: + case WEBKIT_CENTER: + anchor = FloatPoint(nodeRect.x() + (nodeRect.width() - scaledViewportWidth) / 2, topLeftPoint.y()); + break; + case LEFT: + case WEBKIT_LEFT: + anchor = topLeftPoint; + break; + case RIGHT: + case WEBKIT_RIGHT: + anchor = FloatPoint(nodeRect.x() + nodeRect.width() - scaledViewportWidth, topLeftPoint.y()); + break; + case TAAUTO: + case JUSTIFY: + default: + if (renderer->style()->isLeftToRightDirection()) + anchor = topLeftPoint; + else + anchor = FloatPoint(nodeRect.x() + nodeRect.width() - scaledViewportWidth, topLeftPoint.y()); + break; + } + } else + anchor = renderer->style()->isLeftToRightDirection() ? topLeftPoint : FloatPoint(nodeRect.x() + nodeRect.width() - scaledViewportWidth, topLeftPoint.y()); + + if (newBlockHeight <= scaledViewportHeight) { + // The block fits in the viewport so center it. + d->m_finalBlockPoint = FloatPoint(anchor.x() - dx, anchor.y() - dy); + } else { + // The block is longer than the viewport so top align it and add 3 pixel margin. + d->m_finalBlockPoint = FloatPoint(anchor.x() - dx, anchor.y() - 3); + } + +#if ENABLE(VIEWPORT_REFLOW) + // We don't know how long the reflowed block will be so we position it at the top of the screen with a small margin. + if (settings()->textReflowMode() != WebSettings::TextReflowDisabled) { + d->m_finalBlockPoint = FloatPoint(anchor.x() - dx, anchor.y() - 3); + d->m_finalBlockPointReflowOffset = FloatPoint(-dx, -3); + } +#endif + + // Make sure that the original node rect is visible in the screen after the zoom. This is necessary because the identified block rect might + // not be the same as the original node rect, and it could force the original node rect off the screen. + FloatRect br(anchor, FloatSize(scaledViewportWidth, scaledViewportHeight)); + IntPoint clickPoint = d->mapFromTransformed(IntPoint(x, y)); + if (!br.contains(clickPoint)) { + d->m_finalBlockPointReflowOffset.move(0, (clickPoint.y() - scaledViewportHeight / 2) - d->m_finalBlockPoint.y()); + d->m_finalBlockPoint = FloatPoint(d->m_finalBlockPoint.x(), clickPoint.y() - scaledViewportHeight / 2); + } + + // Clamp the finalBlockPoint to not cause any overflow scrolling. + if (d->m_finalBlockPoint.x() < 0) { + d->m_finalBlockPoint.setX(0); + d->m_finalBlockPointReflowOffset.setX(0); + } else if (d->m_finalBlockPoint.x() + scaledViewportWidth > d->contentsSize().width()) { + d->m_finalBlockPoint.setX(d->contentsSize().width() - scaledViewportWidth); + d->m_finalBlockPointReflowOffset.setX(0); + } + + if (d->m_finalBlockPoint.y() < 0) { + d->m_finalBlockPoint.setY(0); + d->m_finalBlockPointReflowOffset.setY(0); + } else if (d->m_finalBlockPoint.y() + scaledViewportHeight > d->contentsSize().height()) { + d->m_finalBlockPoint.setY(d->contentsSize().height() - scaledViewportHeight); + d->m_finalBlockPointReflowOffset.setY(0); + } + + d->m_finalBlockPoint = d->mapToTransformedFloatPoint(d->m_finalBlockPoint); + + // Don't block zoom if the user is zooming and the new scale is only marginally different from the + // oldScale with only a marginal change in scroll position. Ignore scroll difference in the special case + // that the zoom level is the minimumScale. + if (!endOfBlockZoomMode && abs(newScale - oldScale) / oldScale < minimumExpandingRatio) { + const double minimumDisplacement = minimumExpandingRatio * d->transformedActualVisibleSize().width(); + if (oldScale == d->minimumScale() || (distanceBetweenPoints(roundTransformedPoint(d->mapToTransformed(d->scrollPosition())), roundTransformedPoint(d->m_finalBlockPoint)) < minimumDisplacement && abs(newScale - oldScale) / oldScale < 0.10)) { + if (isFirstZoom) { + d->resetBlockZoom(); + return false; + } + // Zoom out of block zoom. + blockZoom(x, y); + return true; + } + } + + d->m_blockZoomFinalScale = newScale; + + // We set this here to make sure we don't try to re-render the page at a different zoom level during loading. + d->m_userPerformedManualZoom = true; + d->m_userPerformedManualScroll = true; + d->m_client->animateBlockZoom(d->m_finalBlockPoint, d->m_blockZoomFinalScale); + + return true; +} + +bool WebPage::isMaxZoomed() const +{ + return (d->currentScale() == d->maximumScale()) || !d->isUserScalable(); +} + +bool WebPage::isMinZoomed() const +{ + return (d->currentScale() == d->minimumScale()) || !d->isUserScalable(); +} + +bool WebPage::isAtInitialZoom() const +{ + return (d->currentScale() == d->initialScale()) || !d->isUserScalable(); +} + +bool WebPagePrivate::shouldZoomOnEscape() const +{ + if (!isUserScalable()) + return false; + + // If the initial scale is not reachable, don't try to zoom. + if (initialScale() < minimumScale() || initialScale() > maximumScale()) + return false; + + // Don't ever zoom in when we press escape. + if (initialScale() >= currentScale()) + return false; + + return currentScale() != initialScale(); +} + +void WebPage::zoomToInitialScale() +{ + if (!d->isUserScalable()) + return; + + d->zoomAboutPoint(d->initialScale(), d->centerOfVisibleContentsRect()); +} + +bool WebPage::zoomToOneOne() +{ + if (!d->isUserScalable()) + return false; + + double scale = 1; + return d->zoomAboutPoint(scale, d->centerOfVisibleContentsRect()); +} + +Platform::IntRect WebPage::focusNodeRect() +{ + return d->focusNodeRect(); +} + +void WebPage::setFocused(bool focused) +{ + FocusController* focusController = d->m_page->focusController(); + focusController->setActive(focused); + if (focused) { + Frame* frame = focusController->focusedFrame(); + if (!frame) + focusController->setFocusedFrame(d->m_mainFrame); + } + focusController->setFocused(focused); +} + +bool WebPage::findNextString(const char* text, bool forward) +{ + return d->m_inPageSearchManager->findNextString(String::fromUTF8(text), forward); +} + +void WebPage::runLayoutTests() +{ +#if ENABLE_DRT + // FIXME: do we need API to toggle this? + d->m_page->settings()->setDeveloperExtrasEnabled(true); + + if (!d->m_dumpRenderTree) + d->m_dumpRenderTree = new DumpRenderTree(this); + d->m_dumpRenderTree->runTests(); +#endif +} + +bool WebPage::enableScriptDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + return true; + + d->m_scriptDebugger = adoptPtr(new JavaScriptDebuggerBlackBerry(this->d)); + + return !!d->m_scriptDebugger; +#endif +} + +bool WebPage::disableScriptDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (!d->m_scriptDebugger) + return true; + + d->m_scriptDebugger.clear(); + return true; +#endif +} + +void WebPage::addBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength) +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->addBreakpoint(url, urlLength, lineNumber, condition, conditionLength); +#endif +} + +void WebPage::updateBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength) +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->updateBreakpoint(url, urlLength, lineNumber, condition, conditionLength); +#endif +} + +void WebPage::removeBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber) +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->removeBreakpoint(url, urlLength, lineNumber); +#endif +} + +bool WebPage::pauseOnExceptions() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + return d->m_scriptDebugger ? d->m_scriptDebugger->pauseOnExceptions() : false; +#endif +} + +void WebPage::setPauseOnExceptions(bool pause) +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->setPauseOnExceptions(pause); +#endif +} + +void WebPage::pauseInDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->pauseInDebugger(); +#endif +} + +void WebPage::resumeDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->resumeDebugger(); +#endif +} + +void WebPage::stepOverStatementInDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->stepOverStatementInDebugger(); +#endif +} + +void WebPage::stepIntoStatementInDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->stepIntoStatementInDebugger(); +#endif +} + +void WebPage::stepOutOfFunctionInDebugger() +{ +#if ENABLE(JAVASCRIPT_DEBUGGER) + if (d->m_scriptDebugger) + d->m_scriptDebugger->stepOutOfFunctionInDebugger(); +#endif +} + +unsigned WebPage::timeoutForJavaScriptExecution() const +{ + return Settings::timeoutForJavaScriptExecution(d->m_page->groupName()); +} + +void WebPage::setTimeoutForJavaScriptExecution(unsigned ms) +{ + Settings::setTimeoutForJavaScriptExecution(d->m_page->groupName(), ms); + + Document* doc = d->m_page->mainFrame()->document(); + if (!doc) + return; + + doc->globalData()->timeoutChecker.setTimeoutInterval(ms); +} + +JSContextRef WebPage::scriptContext() const +{ + if (!d->m_mainFrame) + return 0; + + JSC::Bindings::RootObject *root = d->m_mainFrame->script()->bindingRootObject(); + if (!root) + return 0; + + JSC::ExecState *exec = root->globalObject()->globalExec(); + return toRef(exec); +} + +JSValueRef WebPage::windowObject() const +{ + return toRef(d->m_mainFrame->script()->globalObject(mainThreadNormalWorld())); +} + +// Serialize only the members of HistoryItem which are needed by the client, +// and copy them into a SharedArray. Also include the HistoryItem pointer which +// will be used by the client as an opaque reference to identify the item. +void WebPage::getBackForwardList(SharedArray<BackForwardEntry>& result, unsigned int& resultSize) const +{ + HistoryItemVector entries = static_cast<BackForwardListImpl*>(d->m_page->backForward()->client())->entries(); + resultSize = entries.size(); + result.reset(new BackForwardEntry[resultSize]); + + for (unsigned i = 0; i < resultSize; ++i) { + RefPtr<HistoryItem> entry = entries[i]; + BackForwardEntry& resultEntry = result[i]; + resultEntry.url = entry->urlString(); + resultEntry.originalUrl = entry->originalURLString(); + resultEntry.title = entry->title(); + resultEntry.networkToken = entry->viewState().networkToken; + resultEntry.lastVisitWasHTTPNonGet = entry->lastVisitWasHTTPNonGet(); + resultEntry.id = backForwardIdFromHistoryItem(entry.get()); + + // Make sure the HistoryItem is not disposed while the result list is still being used, to make sure the pointer is not reused + // will be balanced by deref in releaseBackForwardEntry. + entry->ref(); + } +} + +void WebPage::releaseBackForwardEntry(BackForwardId id) const +{ + HistoryItem* item = historyItemFromBackForwardId(id); + ASSERT(item); + item->deref(); +} + +void WebPage::clearBrowsingData() +{ + clearMemoryCaches(); + clearAppCache(d->m_page->groupName()); + clearLocalStorage(); + clearCookieCache(); + clearHistory(); + clearPluginSiteData(); +} + +void WebPage::clearHistory() +{ + // Don't clear the back-forward list as we might like to keep it. +} + +void WebPage::clearCookies() +{ + clearCookieCache(); +} + +void WebPage::clearLocalStorage() +{ + BlackBerry::WebKit::clearLocalStorage(d->m_page->groupName()); + clearDatabase(d->m_page->groupName()); +} + +void WebPage::clearCache() +{ + clearMemoryCaches(); + clearAppCache(d->m_page->groupName()); +} + +void WebPage::clearBackForwardList(bool keepCurrentPage) const +{ + BackForwardListImpl* backForwardList = static_cast<BackForwardListImpl*>(d->m_page->backForward()->client()); + RefPtr<HistoryItem> currentItem = backForwardList->currentItem(); + while (!backForwardList->entries().isEmpty()) + backForwardList->removeItem(backForwardList->entries().last().get()); + if (keepCurrentPage) + backForwardList->addItem(currentItem); +} + +bool WebPage::isEnableLocalAccessToAllCookies() const +{ + return cookieManager().canLocalAccessAllCookies(); +} + +void WebPage::setEnableLocalAccessToAllCookies(bool enabled) +{ + cookieManager().setCanLocalAccessAllCookies(enabled); +} + +void WebPage::addVisitedLink(const unsigned short* url, unsigned int length) +{ + ASSERT(d->m_page); + d->m_page->group().addVisitedLink(url, length); +} + +#if ENABLE(WEBDOM) +WebDOMDocument WebPage::document() const +{ + if (!d->m_mainFrame) + return WebDOMDocument(); + return WebDOMDocument(d->m_mainFrame->document()); +} + +WebDOMNode WebPage::nodeAtPoint(int x, int y) +{ + HitTestResult result = d->m_mainFrame->eventHandler()->hitTestResultAtPoint(d->mapFromTransformed(IntPoint(x, y)), false); + Node* node = result.innerNonSharedNode(); + return WebDOMNode(node); +} + +bool WebPage::getNodeRect(const WebDOMNode& node, Platform::IntRect& result) +{ + Node* nodeImpl = node.impl(); + if (nodeImpl && nodeImpl->renderer()) { + result = nodeImpl->getRect(); + return true; + } + + return false; +} + +bool WebPage::setNodeFocus(const WebDOMNode& node, bool on) +{ + Node* nodeImpl = node.impl(); + + if (nodeImpl && nodeImpl->isFocusable()) { + Document* doc = nodeImpl->document(); + if (Page* page = doc->page()) { + // Modify if focusing on node or turning off focused node. + if (on) { + page->focusController()->setFocusedNode(nodeImpl, doc->frame()); + if (nodeImpl->isElementNode()) + static_cast<Element*>(nodeImpl)->updateFocusAppearance(true); + d->m_inputHandler->didNodeOpenPopup(nodeImpl); + } else if (doc->focusedNode() == nodeImpl) // && !on + page->focusController()->setFocusedNode(0, doc->frame()); + + return true; + } + } + return false; +} + +bool WebPage::setNodeHovered(const WebDOMNode& node, bool on) +{ + if (Node* nodeImpl = node.impl()) { + nodeImpl->setHovered(on); + return true; + } + return false; +} + +bool WebPage::nodeHasHover(const WebDOMNode& node) +{ + if (Node* nodeImpl = node.impl()) { + if (RenderStyle* style = nodeImpl->renderStyle()) + return style->affectedByHoverRules(); + } + return false; +} +#endif + +String WebPagePrivate::findPatternStringForUrl(const KURL& url) const +{ + if ((m_webSettings->shouldHandlePatternUrls() && protocolIs(url, "pattern")) + || protocolIs(url, "tel") + || protocolIs(url, "wtai") + || protocolIs(url, "cti") + || protocolIs(url, "mailto") + || protocolIs(url, "sms") + || protocolIs(url, "pin")) { + return url; + } + return String(); +} + +bool WebPage::defersLoading() const +{ + return d->m_page->defersLoading(); +} + +bool WebPage::willFireTimer() +{ + if (d->isLoading()) + return true; + + return d->m_backingStore->d->willFireTimer(); +} + +void WebPage::notifyPagePause() +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handlePauseEvent(); +} + +void WebPage::notifyPageResume() +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleResumeEvent(); +} + +void WebPage::notifyPageBackground() +{ +#if USE(ACCELERATED_COMPOSITING) + d->suspendRootLayerCommit(); +#endif + + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleBackgroundEvent(); +} + +void WebPage::notifyPageForeground() +{ +#if USE(ACCELERATED_COMPOSITING) + d->resumeRootLayerCommit(); +#endif + + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleForegroundEvent(); +} + +void WebPage::notifyPageFullScreenAllowed() +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleFullScreenAllowedEvent(); +} + +void WebPage::notifyPageFullScreenExit() +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleFullScreenExitEvent(); +} + +void WebPage::notifyDeviceIdleStateChange(bool enterIdle) +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleIdleEvent(enterIdle); +} + +void WebPage::notifyAppActivationStateChange(ActivationStateType activationState) +{ +#if ENABLE(VIDEO) + MediaPlayerPrivate::notifyAppActivatedEvent(activationState == ActivationActive); +#endif + + FOR_EACH_PLUGINVIEW(d->m_pluginViews) { + switch (activationState) { + case ActivationActive: + (*it)->handleAppActivatedEvent(); + break; + case ActivationInactive: + (*it)->handleAppDeactivatedEvent(); + break; + case ActivationStandby: + (*it)->handleAppStandbyEvent(); + break; + default: // FIXME: Get rid of the default to force a compiler error instead of using a runtime error. See PR #121109. + ASSERT_NOT_REACHED(); + break; + } + } +} + +void WebPage::notifySwipeEvent() +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleSwipeEvent(); +} + +void WebPage::notifyScreenPowerStateChanged(bool powered) +{ + FOR_EACH_PLUGINVIEW(d->m_pluginViews) + (*it)->handleScreenPowerEvent(powered); +} + +void WebPage::notifyFullScreenVideoExited(bool done) +{ + UNUSED_PARAM(done); +#if ENABLE(VIDEO) + if (HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(d->m_fullscreenVideoNode.get())) + mediaElement->exitFullscreen(); +#endif +} + +void WebPage::clearPluginSiteData() +{ + PluginDatabase* database = PluginDatabase::installedPlugins(true); + + if (!database) + return; + + Vector<PluginPackage*> plugins = database->plugins(); + + Vector<PluginPackage*>::const_iterator end = plugins.end(); + for (Vector<PluginPackage*>::const_iterator it = plugins.begin(); it != end; ++it) + (*it)->clearSiteData(String()); +} + +void WebPage::onInputLocaleChanged(bool isRTL) +{ + d->onInputLocaleChanged(isRTL); +} + +void WebPage::onNetworkAvailabilityChanged(bool available) +{ + updateOnlineStatus(available); +} + +void WebPage::onCertificateStoreLocationSet(const WebString& caPath) +{ +#if ENABLE(VIDEO) + MediaPlayerPrivate::setCertificatePath(caPath); +#endif +} + +void WebPage::enableWebInspector() +{ + d->m_page->inspectorController()->connectFrontend(); + d->m_page->settings()->setDeveloperExtrasEnabled(true); +} + +void WebPage::disableWebInspector() +{ + d->m_page->inspectorController()->disconnectFrontend(); + d->m_page->settings()->setDeveloperExtrasEnabled(false); +} + +void WebPage::enablePasswordEcho() +{ + d->m_page->settings()->setPasswordEchoEnabled(true); +} + +void WebPage::disablePasswordEcho() +{ + d->m_page->settings()->setPasswordEchoEnabled(false); +} + +void WebPage::dispatchInspectorMessage(const char* message, int length) +{ + String stringMessage(message, length); + d->m_page->inspectorController()->dispatchMessageFromFrontend(stringMessage); +} + +Frame* WebPage::mainFrame() const +{ + return d->m_mainFrame; +} + +#if USE(ACCELERATED_COMPOSITING) +void WebPagePrivate::drawLayersOnCommit() +{ + if (!Platform::userInterfaceThreadMessageClient()->isCurrentThread()) { + // This method will only be called when the layer appearance changed due to + // animations. And only if we don't need a one shot drawing sync. + ASSERT(!needsOneShotDrawingSynchronization()); + + if (!m_webPage->isVisible() || !m_backingStore->d->isActive()) + return; + + m_backingStore->d->willDrawLayersOnCommit(); + + Platform::userInterfaceThreadMessageClient()->dispatchMessage( + Platform::createMethodCallMessage(&WebPagePrivate::drawLayersOnCommit, this)); + return; + } + + if (m_client->window()->windowUsage() == Platform::Graphics::Window::GLES2Usage) { + m_backingStore->d->blitVisibleContents(); + return; // blitVisibleContents() includes drawSubLayers() in this case. + } + + if (!drawSubLayers()) + return; + + // If we use the compositing surface, we need to re-blit the + // backingstore and blend the compositing surface on top of that + // in order to get the newly drawn layers on screen. + if (!SurfacePool::globalSurfacePool()->compositingSurface()) + return; + + // If there are no visible layers, return early. + if (lastCompositingResults().isEmpty() && lastCompositingResults().wasEmpty) + return; + + if (m_backingStore->d->shouldDirectRenderingToWindow()) + return; + + m_backingStore->d->blitVisibleContents(); +} + +bool WebPagePrivate::drawSubLayers(const IntRect& dstRect, const FloatRect& contents) +{ + ASSERT(Platform::userInterfaceThreadMessageClient()->isCurrentThread()); + if (!Platform::userInterfaceThreadMessageClient()->isCurrentThread()) + return false; + + if (m_compositor) { + m_compositor->setCompositingOntoMainWindow( + m_client->window()->windowUsage() == Platform::Graphics::Window::GLES2Usage); + return m_compositor->drawLayers(dstRect, contents); + } + + return false; +} + +bool WebPagePrivate::drawSubLayers() +{ + ASSERT(Platform::userInterfaceThreadMessageClient()->isCurrentThread()); + if (!Platform::userInterfaceThreadMessageClient()->isCurrentThread()) + return false; + + return m_backingStore->d->drawSubLayers(); +} + +void WebPagePrivate::scheduleRootLayerCommit() +{ + if (!m_frameLayers || !m_frameLayers->hasLayer()) + return; + + m_needsCommit = true; + if (!m_rootLayerCommitTimer->isActive()) + m_rootLayerCommitTimer->startOneShot(0); +} + +static bool needsLayoutRecursive(FrameView* view) +{ + if (view->needsLayout()) + return true; + + bool subframesNeedsLayout = false; + const HashSet<RefPtr<Widget> >* viewChildren = view->children(); + HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end(); + for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end && !subframesNeedsLayout; ++current) { + Widget* widget = (*current).get(); + if (widget->isFrameView()) + subframesNeedsLayout |= needsLayoutRecursive(static_cast<FrameView*>(widget)); + } + + return subframesNeedsLayout; +} + +LayerRenderingResults WebPagePrivate::lastCompositingResults() const +{ + if (m_compositor) + return m_compositor->lastCompositingResults(); + return LayerRenderingResults(); +} + +void WebPagePrivate::commitRootLayer(const IntRect& layoutRectForCompositing, + const IntSize& contentsSizeForCompositing) +{ + if (!m_frameLayers || !m_compositor) + return; + + m_compositor->setLayoutRectForCompositing(layoutRectForCompositing); + m_compositor->setContentsSizeForCompositing(contentsSizeForCompositing); + m_compositor->commit(m_frameLayers->rootLayer()); +} + +bool WebPagePrivate::commitRootLayerIfNeeded() +{ + if (m_suspendRootLayerCommit) + return false; + + if (!m_needsCommit) + return false; + + if (!m_frameLayers || !m_frameLayers->hasLayer()) + return false; + + FrameView* view = m_mainFrame->view(); + if (!view) + return false; + + // If we sync compositing layers when a layout is pending, we may cause painting of compositing + // layer content to occur before layout has happened, which will cause paintContents() to bail. + if (needsLayoutRecursive(view)) { + // In case of one shot drawing synchronization, you + // should first layoutIfNeeded, render, then commit and draw the layers. + ASSERT(!needsOneShotDrawingSynchronization()); + return false; + } + + m_needsCommit = false; + // We get here either due to the commit timer, which would have called + // render if a one shot sync was needed. Or we get called from render + // before the timer times out, which means we are doing a one shot anyway. + m_needsOneShotDrawingSynchronization = false; + + if (m_rootLayerCommitTimer->isActive()) + m_rootLayerCommitTimer->stop(); + + m_frameLayers->commitOnWebKitThread(currentScale()); + updateDelegatedOverlays(); + + // Stash the visible content rect according to webkit thread + // This is the rectangle used to layout fixed positioned elements, + // and that's what the layer renderer wants. + IntRect layoutRectForCompositing(scrollPosition(), actualVisibleSize()); + IntSize contentsSizeForCompositing = contentsSize(); + + // Commit changes made to the layers synchronously with the compositing thread. + Platform::userInterfaceThreadMessageClient()->dispatchSyncMessage( + Platform::createMethodCallMessage( + &WebPagePrivate::commitRootLayer, + this, + layoutRectForCompositing, + contentsSizeForCompositing)); + + return true; +} + +void WebPagePrivate::rootLayerCommitTimerFired(Timer<WebPagePrivate>*) +{ + if (m_suspendRootLayerCommit) + return; + + // The commit timer may have fired just before the layout timer, or for some + // other reason we need layout. It's not allowed to commit when a layout is + // pending, becaues a commit can cause parts of the web page to be rendered + // to texture. + // The layout can also turn of compositing altogether, so we need to be prepared + // to handle a one shot drawing synchronization after the layout. + requestLayoutIfNeeded(); + + bool isSingleTargetWindow = SurfacePool::globalSurfacePool()->compositingSurface() + || m_client->window()->windowUsage() == Platform::Graphics::Window::GLES2Usage; + + // If we are doing direct rendering and have a single rendering target, + // committing is equivalent to a one shot drawing synchronization. + // We need to re-render the web page, re-render the layers, and + // then blit them on top of the re-rendered web page. + if (isSingleTargetWindow && m_backingStore->d->shouldDirectRenderingToWindow()) + setNeedsOneShotDrawingSynchronization(); + + if (needsOneShotDrawingSynchronization()) { + const IntRect windowRect = IntRect(IntPoint::zero(), viewportSize()); + m_backingStore->d->repaint(windowRect, true /*contentChanged*/, true /*immediate*/); + return; + } + + // If the web page needs layout, the commit will fail. + // No need to draw the layers if nothing changed. + if (commitRootLayerIfNeeded()) + drawLayersOnCommit(); +} + +void WebPagePrivate::setIsAcceleratedCompositingActive(bool active) +{ + // Backing store can be null here because it happens during teardown. + if (m_isAcceleratedCompositingActive == active || !m_backingStore) + return; + + m_isAcceleratedCompositingActive = active; + + if (!active) { + m_compositor.clear(); + resetCompositingSurface(); + return; + } + + if (!m_compositor) { + m_compositor = adoptPtr(new WebPageCompositor(this)); + m_isAcceleratedCompositingActive = m_compositor->hardwareCompositing(); + if (!m_isAcceleratedCompositingActive) + m_compositor.clear(); + } +} + +void WebPagePrivate::resetCompositingSurface() +{ + if (!Platform::userInterfaceThreadMessageClient()->isCurrentThread()) { + Platform::userInterfaceThreadMessageClient()->dispatchMessage( + Platform::createMethodCallMessage( + &WebPagePrivate::resetCompositingSurface, this)); + return; + } + + if (m_compositor) + m_compositor->setLastCompositingResults(LayerRenderingResults()); +} + +void WebPagePrivate::setRootLayerWebKitThread(Frame* frame, LayerWebKitThread* layer) +{ + // This method updates the FrameLayers based on input from WebCore. + // FrameLayers keeps track of the layer proxies attached to frames. + // We will have to compute a new root layer and update the compositor. + if (!layer && !m_frameLayers) + return; + + if (!layer) { + ASSERT(m_frameLayers); + m_frameLayers->removeLayerByFrame(frame); + if (!m_frameLayers->hasLayer()) + m_frameLayers.clear(); + } else { + if (!m_frameLayers) + m_frameLayers = adoptPtr(new FrameLayers(this)); + + if (!m_frameLayers->containsLayerForFrame(frame)) + m_frameLayers->addLayer(frame, layer); + + ASSERT(m_frameLayers); + } + + LayerCompositingThread* rootLayerCompositingThread = 0; + if (m_frameLayers && m_frameLayers->rootLayer()) + rootLayerCompositingThread = m_frameLayers->rootLayer()->layerCompositingThread(); + + setRootLayerCompositingThread(rootLayerCompositingThread); +} + +void WebPagePrivate::setRootLayerCompositingThread(LayerCompositingThread* layer) +{ + if (!Platform::userInterfaceThreadMessageClient()->isCurrentThread()) { + Platform::userInterfaceThreadMessageClient()->dispatchSyncMessage( + Platform::createMethodCallMessage(&WebPagePrivate::setRootLayerCompositingThread, this, layer)); + return; + } + + // Depending on whether we have a root layer or not, + // this method will turn on or off accelerated compositing. + if (!layer) { + // Don't ASSERT(m_compositor) here because we may be called in + // the process of destruction of WebPage where we have already + // called syncDestroyCompositorOnCompositingThread() to destroy + // the compositor. + setIsAcceleratedCompositingActive(false); + return; + } + + if (!m_compositor) + setIsAcceleratedCompositingActive(true); + + // Don't ASSERT(m_compositor) here because setIsAcceleratedCompositingActive(true) + // may not turn accelerated compositing on since m_backingStore is 0. + if (m_compositor) + m_compositor->setRootLayer(layer); +} + +void WebPagePrivate::destroyCompositor() +{ + m_compositor.clear(); +} + +void WebPagePrivate::syncDestroyCompositorOnCompositingThread() +{ + if (!m_compositor) + return; + + Platform::userInterfaceThreadMessageClient()->dispatchSyncMessage( + Platform::createMethodCallMessage( + &WebPagePrivate::destroyCompositor, this)); +} + +void WebPagePrivate::destroyLayerResources() +{ + m_compositor->releaseLayerResources(); +} + +void WebPagePrivate::suspendRootLayerCommit() +{ + if (m_suspendRootLayerCommit) + return; + + m_suspendRootLayerCommit = true; + + if (!m_frameLayers || !m_frameLayers->hasLayer() || !m_compositor) + return; + + Platform::userInterfaceThreadMessageClient()->dispatchSyncMessage( + Platform::createMethodCallMessage(&WebPagePrivate::destroyLayerResources, this)); +} + +void WebPagePrivate::resumeRootLayerCommit() +{ + if (!m_suspendRootLayerCommit) + return; + + m_suspendRootLayerCommit = false; + m_needsCommit = true; + + // Recreate layer resources if needed. + commitRootLayerIfNeeded(); +} + +bool WebPagePrivate::needsOneShotDrawingSynchronization() +{ + return m_needsOneShotDrawingSynchronization; +} + +void WebPagePrivate::setNeedsOneShotDrawingSynchronization() +{ + // This means we have to commit layers on next render, or render on the next commit, + // whichever happens first. + m_needsCommit = true; + m_needsOneShotDrawingSynchronization = true; +} +#endif // USE(ACCELERATED_COMPOSITING) + +void WebPagePrivate::enterFullscreenForNode(Node* node) +{ +#if ENABLE(VIDEO) + if (!node || !node->hasTagName(HTMLNames::videoTag)) + return; + + MediaPlayer* player = static_cast<HTMLMediaElement*>(node)->player(); + if (!player) + return; + + MediaPlayerPrivate* mmrPlayer = static_cast<MediaPlayerPrivate*>(player->implementation()); + if (!mmrPlayer) + return; + + Platform::Graphics::Window* window = mmrPlayer->windowGet(); + if (!window) + return; + + unsigned x, y, width, height; + mmrPlayer->windowPositionGet(x, y, width, height); + + const char* contextName = mmrPlayer->mmrContextNameGet(); + if (!contextName) + return; + + mmrPlayer->setFullscreenWebPageClient(m_client); + m_fullscreenVideoNode = node; + m_client->fullscreenStart(contextName, window, x, y, width, height); +#endif +} + +void WebPagePrivate::exitFullscreenForNode(Node* node) +{ +#if ENABLE(VIDEO) + if (m_fullscreenVideoNode.get()) { + m_client->fullscreenStop(); + m_fullscreenVideoNode = 0; + } + + if (!node || !node->hasTagName(HTMLNames::videoTag)) + return; + + MediaPlayer* player = static_cast<HTMLMediaElement*>(node)->player(); + if (!player) + return; + + MediaPlayerPrivate* mmrPlayer = static_cast<MediaPlayerPrivate*>(player->implementation()); + if (!mmrPlayer) + return; + + // Fullscreen mode is being turned off, so MediaPlayerPrivate no longer needs the pointer. + mmrPlayer->setFullscreenWebPageClient(0); +#endif +} + +void WebPagePrivate::didChangeSettings(WebSettings* webSettings) +{ + Settings* coreSettings = m_page->settings(); + m_page->setGroupName(webSettings->pageGroupName()); + coreSettings->setXSSAuditorEnabled(webSettings->xssAuditorEnabled()); + coreSettings->setLoadsImagesAutomatically(webSettings->loadsImagesAutomatically()); + coreSettings->setShouldDrawBorderWhileLoadingImages(webSettings->shouldDrawBorderWhileLoadingImages()); + coreSettings->setScriptEnabled(webSettings->isJavaScriptEnabled()); + coreSettings->setPrivateBrowsingEnabled(webSettings->isPrivateBrowsingEnabled()); + coreSettings->setDefaultFixedFontSize(webSettings->defaultFixedFontSize()); + coreSettings->setDefaultFontSize(webSettings->defaultFontSize()); + coreSettings->setMinimumFontSize(webSettings->minimumFontSize()); + coreSettings->setSerifFontFamily(webSettings->serifFontFamily().impl()); + coreSettings->setFixedFontFamily(webSettings->fixedFontFamily().impl()); + coreSettings->setSansSerifFontFamily(webSettings->sansSerifFontFamily().impl()); + coreSettings->setStandardFontFamily(webSettings->standardFontFamily().impl()); + coreSettings->setJavaScriptCanOpenWindowsAutomatically(webSettings->canJavaScriptOpenWindowsAutomatically()); + coreSettings->setAllowScriptsToCloseWindows(webSettings->canJavaScriptOpenWindowsAutomatically()); // Why are we using the same value as setJavaScriptCanOpenWindowsAutomatically()? + coreSettings->setPluginsEnabled(webSettings->arePluginsEnabled()); + coreSettings->setDefaultTextEncodingName(webSettings->defaultTextEncodingName().impl()); + coreSettings->setDownloadableBinaryFontsEnabled(webSettings->downloadableBinaryFontsEnabled()); + coreSettings->setSpatialNavigationEnabled(m_webSettings->isSpatialNavigationEnabled()); + + // UserScalable should be reset by new settings. + setUserScalable(webSettings->isUserScalable()); + + WebString stylesheetURL = webSettings->userStyleSheetString(); + if (stylesheetURL.isEmpty()) + stylesheetURL = webSettings->userStyleSheetLocation(); + if (!stylesheetURL.isEmpty()) + coreSettings->setUserStyleSheetLocation(KURL(KURL(), stylesheetURL)); + + coreSettings->setFirstScheduledLayoutDelay(webSettings->firstScheduledLayoutDelay()); + coreSettings->setUseCache(webSettings->useWebKitCache()); + +#if ENABLE(SQL_DATABASE) + // DatabaseTracker can only be initialized for once, so it doesn't + // make sense to change database path after DatabaseTracker has + // already been initialized. + static bool dbinit = false; + if (!dbinit && !webSettings->databasePath().isEmpty()) { + dbinit = true; + DatabaseTracker::initializeTracker(webSettings->databasePath()); + } + + // The directory of cacheStorage for one page group can only be initialized once. + static bool acinit = false; + if (!acinit && !webSettings->appCachePath().isEmpty()) { + acinit = true; + cacheStorage().setCacheDirectory(webSettings->appCachePath()); + } + + coreSettings->setLocalStorageDatabasePath(webSettings->localStoragePath()); + Database::setIsAvailable(webSettings->isDatabasesEnabled()); + DatabaseSync::setIsAvailable(webSettings->isDatabasesEnabled()); + + coreSettings->setLocalStorageEnabled(webSettings->isLocalStorageEnabled()); + coreSettings->setOfflineWebApplicationCacheEnabled(webSettings->isAppCacheEnabled()); + + m_page->group().groupSettings()->setLocalStorageQuotaBytes(webSettings->localStorageQuota()); + coreSettings->setUsesPageCache(webSettings->maximumPagesInCache()); + coreSettings->setFrameFlatteningEnabled(webSettings->isFrameFlatteningEnabled()); +#endif + +#if ENABLE(WEB_SOCKETS) + WebSocket::setIsAvailable(webSettings->areWebSocketsEnabled()); +#endif + +#if ENABLE(VIEWPORT_REFLOW) + coreSettings->setTextReflowEnabled(webSettings->textReflowMode() == WebSettings::TextReflowEnabled); +#endif + + // FIXME: We don't want HTMLTokenizer to yield for anything other than email case because + // call to currentTime() is too expensive on our platform. See RIM Bug #746. + coreSettings->setShouldUseFirstScheduledLayoutDelay(webSettings->isEmailMode()); + coreSettings->setProcessHTTPEquiv(!webSettings->isEmailMode()); + + coreSettings->setShouldUseCrossOriginProtocolCheck(!webSettings->allowCrossSiteRequests()); + + cookieManager().setPrivateMode(webSettings->isPrivateBrowsingEnabled()); + + if (m_mainFrame && m_mainFrame->view()) { + Color backgroundColor(webSettings->backgroundColor()); + m_mainFrame->view()->updateBackgroundRecursively(backgroundColor, backgroundColor.hasAlpha()); + } +} + +IntSize WebPagePrivate::defaultMaxLayoutSize() +{ + static IntSize size; + if (size.isEmpty()) + size = IntSize(std::max(1024, Platform::Graphics::Screen::landscapeWidth()), + std::max(768, Platform::Graphics::Screen::landscapeHeight())); + + return size; +} + +WebString WebPage::textHasAttribute(const WebString& query) const +{ + if (Document* doc = d->m_page->focusController()->focusedOrMainFrame()->document()) + return doc->queryCommandValue(query); + + return ""; +} + +void WebPage::setJavaScriptCanAccessClipboard(bool enabled) +{ + d->m_page->settings()->setJavaScriptCanAccessClipboard(enabled); +} + +#if USE(ACCELERATED_COMPOSITING) +void WebPagePrivate::blitVisibleContents() +{ + if (m_backingStore->d->shouldDirectRenderingToWindow()) + return; + + m_backingStore->d->blitVisibleContents(); +} +#endif + +void WebPage::setWebGLEnabled(bool enabled) +{ + if (!Platform::ITPolicy::isWebGLEnabled()) { + d->m_page->settings()->setWebGLEnabled(false); + return; + } + d->m_page->settings()->setWebGLEnabled(enabled); +} + +bool WebPage::isWebGLEnabled() const +{ + return d->m_page->settings()->webGLEnabled(); +} + +void WebPagePrivate::setNeedTouchEvents(bool value) +{ + m_needTouchEvents = value; +} + +} +} diff --git a/Source/WebKit/blackberry/Api/WebPage.h b/Source/WebKit/blackberry/Api/WebPage.h new file mode 100644 index 000000000..489f4536c --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebPage.h @@ -0,0 +1,354 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebPage_h +#define WebPage_h + +#include "ActiveNodeContext.h" +#include "BlackBerryGlobal.h" +#include <BlackBerryPlatformGuardedPointer.h> +#include <BlackBerryPlatformInputEvents.h> +#include <imf/input_data.h> +#include <network/NetworkRequest.h> + +struct OpaqueJSContext; +typedef const struct OpaqueJSContext* JSContextRef; + +struct OpaqueJSValue; +typedef const struct OpaqueJSValue* JSValueRef; + +namespace WebCore { +class ChromeClientBlackBerry; +class EditorClientBlackBerry; +class Element; +class Frame; +class FrameLoaderClientBlackBerry; +class GeolocationControllerClientBlackBerry; +class IconDatabaseClientBlackBerry; +class InspectorClientBlackBerry; +class JavaScriptDebuggerBlackBerry; +class Node; +class RenderObject; +class VisibleSelection; +} + +class WebDOMDocument; +class WebDOMNode; +template<typename T> class SharedArray; + +namespace BlackBerry { +namespace Platform { +class IntPoint; +class IntRect; +class IntSize; +class KeyboardEvent; +class MouseEvent; +class TouchEvent; +class TouchPoint; +} + +namespace WebKit { + +class BackingStore; +class BackingStoreClient; +class BackingStorePrivate; +class DumpRenderTreeClient; +class RenderQueue; +class WebPageClient; +class WebPageGroupLoadDeferrer; +class WebPagePrivate; +class WebSettings; + +enum JavaScriptDataType { JSUndefined = 0, JSNull, JSBoolean, JSNumber, JSString, JSObject, JSException, JSDataTypeMax }; + +enum ActivationStateType { ActivationActive, ActivationInactive, ActivationStandby }; + +enum TargetDetectionStrategy {PointBased, RectBased}; + +class BLACKBERRY_EXPORT WebPage : public Platform::GuardedPointerBase { +public: + WebPage(WebPageClient*, const WebString& pageGroupName, const Platform::IntRect&); + void destroy(); + + WebPageClient* client() const; + + void load(const char* url, const char* networkToken, bool isInitial = false); + + void loadExtended(const char* url, const char* networkToken, const char* method, Platform::NetworkRequest::CachePolicy = Platform::NetworkRequest::UseProtocolCachePolicy, const char* data = 0, size_t dataLength = 0, const char* const* headers = 0, size_t headersLength = 0, bool mustHandleInternally = false); + + void loadFile(const char* path, const char* overrideContentType = ""); + + void loadString(const char* string, const char* baseURL, const char* contentType = "text/html", const char* failingURL = 0); + + void download(const Platform::NetworkRequest&); + + bool executeJavaScript(const char* script, JavaScriptDataType& returnType, WebString& returnValue); + + // This will execute the script even if in-page JavaScript is disabled. + bool executeJavaScriptInIsolatedWorld(const char* script, JavaScriptDataType& returnType, WebString& returnValue); + + // Takes a UTF16 encoded script that is used explicitly by the pattern matching code + bool executeJavaScriptInIsolatedWorld(const std::wstring& script, JavaScriptDataType& returnType, WebString& returnValue); + + void initializeIconDataBase(); + + void stopLoading(); + + // This will force any unload handlers to run. + void prepareToDestroy(); + + void reload(); + void reloadFromCache(); + + WebSettings* settings() const; + + void setVisible(bool); + bool isVisible() const; + + void setScreenOrientation(int); + void applyPendingOrientationIfNeeded(); + + Platform::IntSize viewportSize() const; + void setViewportSize(const Platform::IntSize& viewportSize, bool ensureFocusElementVisible = true); + + void resetVirtualViewportOnCommitted(bool reset); + void setVirtualViewportSize(int width, int height); + + // Used for default layout size unless overridden by web content or by other APIs. + void setDefaultLayoutSize(int width, int height); + + bool mouseEvent(const Platform::MouseEvent&, bool* wheelDeltaAccepted = 0); + + // Handles native javascript touch events. + bool touchEvent(const Platform::TouchEvent&); + + // For conversion to mouse events. + void touchEventCancel(); + void touchEventCancelAndClearFocusedNode(); + bool touchPointAsMouseEvent(const Platform::TouchPoint&); + + // Returns true if the key stroke was handled by WebKit. + bool keyEvent(const Platform::KeyboardEvent&); + + WebString title() const; + WebString selectedText() const; + WebString cutSelectedText(); + void insertText(const WebString&); + void clearCurrentInputField(); + + void cut(); + void copy(); + void paste(); + + // Text encoding. + WebString textEncoding(); + WebString forcedTextEncoding(); + void setForcedTextEncoding(const char*); + + // Scroll position returned is in transformed coordinates. + Platform::IntPoint scrollPosition() const; + // Scroll position provided should be in transformed coordinates. + void setScrollPosition(const Platform::IntPoint&); + bool scrollBy(const Platform::IntSize&, bool scrollMainFrame = true); + void notifyInRegionScrollStatusChanged(bool status); + void setScrollOriginPoint(const Platform::IntPoint&); + + BackingStore* backingStore() const; + + bool zoomToFit(); + bool zoomToOneOne(); + void zoomToInitialScale(); + bool blockZoom(int x, int y); + void blockZoomAnimationFinished(); + bool isAtInitialZoom() const; + bool isMaxZoomed() const; + bool isMinZoomed() const; + bool pinchZoomAboutPoint(double scale, int x, int y); + + bool isUserScalable() const; + double currentScale() const; + double initialScale() const; + double zoomToFitScale() const; + void setInitialScale(double); + double minimumScale() const; + void setMinimumScale(double); + double maximumScale() const; + void setMaximumScale(double); + + void assignFocus(Platform::FocusDirection); + + Platform::IntRect focusNodeRect(); + + void setFocused(bool); + + void clearBrowsingData(); + void clearHistory(); + void clearCookies(); + void clearCache(); + void clearLocalStorage(); + + void runLayoutTests(); + + // Finds and selects the next utf8 string that is a case sensitive + // match in the web page. It will wrap the web page if it reaches + // the end. An empty string will result in no match and no selection. + // Returns true if the string matched and false if not. + bool findNextString(const char*, bool forward = true); + + // JavaScriptDebugger interface. + bool enableScriptDebugger(); + bool disableScriptDebugger(); + + JSContextRef scriptContext() const; + JSValueRef windowObject() const; + + void addBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength); + void updateBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength); + void removeBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber); + + bool pauseOnExceptions(); + void setPauseOnExceptions(bool); + + void pauseInDebugger(); + void resumeDebugger(); + + void stepOverStatementInDebugger(); + void stepIntoStatementInDebugger(); + void stepOutOfFunctionInDebugger(); + + unsigned timeoutForJavaScriptExecution() const; + void setTimeoutForJavaScriptExecution(unsigned ms); + + void setCaretHighlightStyle(Platform::CaretHighlightStyle); + + // IMF functions. + bool setBatchEditingActive(bool); + bool setInputSelection(unsigned start, unsigned end); + int inputCaretPosition() const; + bool deleteTextRelativeToCursor(unsigned leftOffset, unsigned rightOffset); + spannable_string_t* selectedText(int32_t flags); + spannable_string_t* textBeforeCursor(int32_t length, int32_t flags); + spannable_string_t* textAfterCursor(int32_t length, int32_t flags); + extracted_text_t* extractedTextRequest(extracted_text_request_t*, int32_t flags); + int32_t setComposingRegion(int32_t start, int32_t end); + int32_t finishComposition(); + int32_t setComposingText(spannable_string_t*, int32_t relativeCursorPosition); + int32_t commitText(spannable_string_t*, int32_t relativeCursorPosition); + + void spellCheckingEnabled(bool); + + void setSelection(const Platform::IntPoint& startPoint, const Platform::IntPoint& endPoint); + void setCaretPosition(const Platform::IntPoint&); + void selectAtPoint(const Platform::IntPoint&); + void selectionCancelled(); + bool selectionContains(const Platform::IntPoint&); + + void popupListClosed(int size, bool* selecteds); + void popupListClosed(int index); + void setDateTimeInput(const WebString& value); + void setColorInput(const WebString& value); + + void onInputLocaleChanged(bool isRTL); + static void onNetworkAvailabilityChanged(bool available); + static void onCertificateStoreLocationSet(const WebString& caPath); + + WebString textHasAttribute(const WebString& query) const; + + ActiveNodeContext activeNodeContext(TargetDetectionStrategy) const; + + typedef intptr_t BackForwardId; + struct BackForwardEntry { + WebString url; + WebString originalUrl; + WebString title; + WebString networkToken; + BackForwardId id; + bool lastVisitWasHTTPNonGet; + }; + + bool canGoBackOrForward(int delta) const; + // Returns false if there is no page for the given delta (eg. + // attempt to go back with -1 when on the first page). + bool goBackOrForward(int delta); + void goToBackForwardEntry(BackForwardId); + + int backForwardListLength() const; + void getBackForwardList(SharedArray<BackForwardEntry>& result, unsigned& resultLength) const; + void releaseBackForwardEntry(BackForwardId) const; + void clearBackForwardList(bool keepCurrentPage) const; + + void addVisitedLink(const unsigned short* url, unsigned length); + +#if defined(ENABLE_WEBDOM) && ENABLE_WEBDOM + WebDOMDocument document() const; + WebDOMNode nodeAtPoint(int x, int y); + bool getNodeRect(const WebDOMNode&, Platform::IntRect& result); + bool setNodeFocus(const WebDOMNode&, bool on); + bool setNodeHovered(const WebDOMNode&, bool on); + bool nodeHasHover(const WebDOMNode&); +#endif + + bool defersLoading() const; + + bool willFireTimer(); + + bool isEnableLocalAccessToAllCookies() const; + void setEnableLocalAccessToAllCookies(bool); + + void enableWebInspector(); + void disableWebInspector(); + void enablePasswordEcho(); + void disablePasswordEcho(); + void dispatchInspectorMessage(const char* message, int length); + WebCore::Frame* mainFrame() const; + + // FIXME: Needs API review on this header. See PR #120402. + void notifyPagePause(); + void notifyPageResume(); + void notifyPageBackground(); + void notifyPageForeground(); + void notifyPageFullScreenAllowed(); + void notifyPageFullScreenExit(); + void notifyDeviceIdleStateChange(bool enterIdle); + void notifyAppActivationStateChange(ActivationStateType); + void notifySwipeEvent(); + void notifyScreenPowerStateChanged(bool powered); + void notifyFullScreenVideoExited(bool done); + void clearPluginSiteData(); + void setJavaScriptCanAccessClipboard(bool); + bool isWebGLEnabled() const; + void setWebGLEnabled(bool); + + void destroyWebPageCompositor(); + +private: + ~WebPage(); + + friend class WebKit::BackingStore; + friend class WebKit::BackingStoreClient; + friend class WebKit::BackingStorePrivate; + friend class WebKit::RenderQueue; + friend class WebKit::WebPageGroupLoadDeferrer; + friend class WebCore::ChromeClientBlackBerry; + friend class WebCore::FrameLoaderClientBlackBerry; + WebPagePrivate* d; +}; +} +} + +#endif // WebPage_h diff --git a/Source/WebKit/blackberry/Api/WebPageClient.h b/Source/WebKit/blackberry/Api/WebPageClient.h new file mode 100644 index 000000000..74b735c77 --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebPageClient.h @@ -0,0 +1,288 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebPageClient_h +#define WebPageClient_h + +#include "BlackBerryGlobal.h" +#include "WebString.h" + +#include <BlackBerryPlatformCursor.h> +#include <BlackBerryPlatformInputEvents.h> +#include <BlackBerryPlatformNavigationType.h> +#include <BlackBerryPlatformPrimitives.h> +#include <interaction/ScrollViewBase.h> +#include <vector> + +template<typename T> class ScopeArray; +template<typename T> class SharedArray; + +typedef void* WebFrame; + +namespace BlackBerry { + +namespace Platform { +class FilterStream; +class GeoTrackerListener; +class IntRectRegion; +class NetworkRequest; +class NetworkStreamFactory; + +namespace Graphics { +class Window; +} +} + +namespace WebKit { +class WebPage; + +class BLACKBERRY_EXPORT WebPageClient { +public: + virtual ~WebPageClient() { } + enum WindowStyleFlag { + FlagWindowHasMenuBar = 0x00000001, + FlagWindowHasToolBar = 0x00000002, + FlagWindowHasLocationBar = 0x00000004, + FlagWindowHasStatusBar = 0x00000008, + FlagWindowHasScrollBar = 0x00000010, + FlagWindowIsResizable = 0x00000020, + FlagWindowIsFullScreen = 0x00000040, + FlagWindowIsDialog = 0x00000080, + FlagWindowDefault = 0xFFFFFFFF, + }; + + enum FocusType { + FocusUnknown = 0, + FocusNone, + FocusCanvas, + FocusImage, + FocusInputButton, + FocusInputCheckBox, + FocusInputColor, + FocusInputDate, + FocusInputDateTime, + FocusInputDateTimeLocal, + FocusInputEmail, + FocusInputFile, + FocusInputImage, + FocusInputMonth, + FocusInputNumber, + FocusInputPassword, + FocusInputRadio, + FocusInputRange, + FocusInputReset, + FocusInputSearch, + FocusInputSubmit, + FocusInputTelephone, + FocusInputText, + FocusInputTime, + FocusInputURL, + FocusInputWeek, + FocusInputUnknown, + FocusLink, + FocusObject, + FocusSelect, + FocusSVGElement, + FocusTextArea, + FocusVideo, + }; + + enum AlertType { + MediaOK = 0, + MediaDecodeError, + MediaMetaDataError, + MediaMetaDataTimeoutError, + MediaNoMetaDataError, + MediaVideoReceiveError, + MediaAudioReceiveError, + MediaInvalidError, + }; + + virtual int getInstanceId() const = 0; + + virtual void notifyLoadStarted() = 0; + virtual void notifyLoadCommitted(const unsigned short* originalUrl, unsigned int originalUrlLength, const unsigned short* finalUrl, unsigned int finalUrlLength, const unsigned short* networkToken, unsigned int networkTokenLength) = 0; + virtual void notifyLoadFailedBeforeCommit(const unsigned short* originalUrl, unsigned int originalUrlLength, const unsigned short* finalUrl, unsigned int finalUrlLength, const unsigned short* networkToken, unsigned int networkTokenLength) = 0; + virtual void notifyLoadToAnchor(const unsigned short* url, unsigned int urlLength, const unsigned short* networkToken, unsigned int networkTokenLength) = 0; + virtual void notifyLoadProgress(int percentage) = 0; + virtual void notifyLoadReadyToRender(bool pageIsVisuallyNonEmpty) = 0; + virtual void notifyFirstVisuallyNonEmptyLayout() = 0; + virtual void notifyLoadFinished(int status) = 0; + virtual void notifyClientRedirect(const unsigned short* originalUrl, unsigned int originalUrlLength, const unsigned short* finalUrl, unsigned int finalUrlLength) = 0; + + virtual void notifyFrameDetached(const WebFrame) = 0; + + virtual void notifyRunLayoutTestsFinished() = 0; + + virtual void notifyInRegionScrollingStartingPointChanged(std::vector<Platform::ScrollViewBase>) = 0; + + virtual void notifyDocumentOnLoad() = 0; + + virtual void notifyWindowObjectCleared() = 0; + virtual WebString invokeClientJavaScriptCallback(const char* const* args, unsigned numArgs) = 0; + + virtual void addMessageToConsole(const unsigned short* message, unsigned messageLength, const unsigned short* source, unsigned sourceLength, unsigned lineNumber) = 0; + virtual int showAlertDialog(AlertType) = 0; + + virtual void runJavaScriptAlert(const unsigned short* message, unsigned messageLength, const char* origin, unsigned originLength) = 0; + virtual bool runJavaScriptConfirm(const unsigned short* message, unsigned messageLength, const char* origin, unsigned originLength) = 0; + virtual bool runJavaScriptPrompt(const unsigned short* message, unsigned messageLength, const unsigned short* defaultValue, unsigned defaultValueLength, const char* origin, unsigned originLength, WebString& result) = 0; + + virtual bool shouldInterruptJavaScript() = 0; + + virtual void javascriptSourceParsed(const unsigned short* url, unsigned urlLength, const unsigned short* script, unsigned scriptLength) = 0; + virtual void javascriptParsingFailed(const unsigned short* url, unsigned urlLength, const unsigned short* error, unsigned errorLength, int lineNumber) = 0; + virtual void javascriptPaused(const unsigned short* stack, unsigned stackLength) = 0; + virtual void javascriptContinued() = 0; + + // All of these methods use transformed coordinates. + virtual void contentsSizeChanged(const Platform::IntSize&) const = 0; + virtual void scrollChanged(const Platform::IntPoint&) const = 0; + virtual void zoomChanged(bool isMinZoomed, bool isMaxZoomed, bool isAtInitialZoom, double newZoom) const = 0; + + virtual void setPageTitle(const unsigned short* title, unsigned titleLength) = 0; + + virtual Platform::Graphics::Window* window() const = 0; + + virtual void notifyContentRendered(const Platform::IntRect&) = 0; + virtual void notifyScreenRotated() = 0; + + virtual void drawTapHighlight(const Platform::IntRectRegion&, int red, int green, int blue, int alpha, bool hideAfterScroll) = 0; + virtual void hideTapHighlight() = 0; + + virtual void focusChanged(FocusType, int elementId) = 0; + virtual void inputFocusGained(Platform::BlackBerryInputType, int inputStyle, bool waitForExplicitKeyboardShowCall) = 0; + virtual void inputFocusLost() = 0; + virtual void inputTextChanged() = 0; + virtual void inputSelectionChanged(unsigned selectionStart, unsigned selectionEnd) = 0; + virtual void inputLearnText(wchar_t* text, int length) = 0; + + virtual void showVirtualKeyboard(bool) = 0; + + virtual void checkSpellingOfString(const unsigned short* text, int length, int& misspellingLocation, int& misspellingLength) = 0; + virtual void requestSpellingSuggestionsForString(unsigned start, unsigned end) = 0; + + virtual void notifySelectionDetailsChanged(const Platform::IntRect& start, const Platform::IntRect& end, const Platform::IntRectRegion&) = 0; + virtual void cancelSelectionVisuals() = 0; + virtual void notifySelectionHandlesReversed() = 0; + virtual void notifyCaretChanged(const Platform::IntRect& caret, bool userTouchTriggered) = 0; + + virtual void cursorChanged(Platform::CursorType, const char* url, int x, int y) = 0; + + virtual void requestGeolocationPermission(Platform::GeoTrackerListener*, void* context, const char* origin, unsigned originLength) = 0; + virtual void cancelGeolocationPermission(Platform::GeoTrackerListener*, void* context) = 0; + virtual Platform::NetworkStreamFactory* networkStreamFactory() = 0; + + virtual void handleStringPattern(const unsigned short* pattern, unsigned length) = 0; + virtual void handleExternalLink(const Platform::NetworkRequest&, const unsigned short* context, unsigned contextLength, bool isClientRedirect) = 0; + + virtual void resetBackForwardList(unsigned listSize, unsigned currentIndex) = 0; + + virtual void openPopupList(bool multiple, int size, const ScopeArray<WebString>& labels, bool* enableds, const int* itemType, bool* selecteds) = 0; + virtual void openDateTimePopup(int type, const WebString& value, const WebString& min, const WebString& max, double step) = 0; + virtual void openColorPopup(const WebString& value) = 0; + + virtual bool chooseFilenames(bool allowMultiple, const WebString& acceptTypes, const SharedArray<WebString>& initialFiles, unsigned initialFileSize, SharedArray<WebString>& chosenFiles, unsigned& chosenFileSize) = 0; + + virtual void loadPluginForMimetype(int, int width, int height, const SharedArray<WebString>& paramNames, const SharedArray<WebString>& paramValues, int size, const char* url) = 0; + virtual void notifyPluginRectChanged(int, Platform::IntRect rectChanged) = 0; + virtual void destroyPlugin(int) = 0; + virtual void playMedia(int) = 0; + virtual void pauseMedia(int) = 0; + virtual float getTime(int) = 0; + virtual void setTime(int, float) = 0; + virtual void setVolume(int, float) = 0; + virtual void setMuted(int, bool) = 0; + + virtual WebPage* createWindow(int x, int y, int width, int height, unsigned flags, const WebString& url, const WebString& windowName) = 0; + + virtual void scheduleCloseWindow() = 0; + + // Database interface. + virtual unsigned long long databaseQuota(const unsigned short* origin, unsigned originLength, const unsigned short* databaseName, unsigned databaseNameLength, unsigned long long totalUsage, unsigned long long originUsage, unsigned long long estimatedSize) = 0; + + virtual void setIconForUrl(const char* originalPageUrl, const char* finalPageUrl, const char* iconUrl) = 0; + virtual void setFavicon(int width, int height, unsigned char* iconData, const char* url) = 0; + virtual void setLargeIcon(const char* iconUrl) = 0; + virtual void setWebAppCapable() = 0; + virtual void setSearchProviderDetails(const char* title, const char* documentUrl) = 0; + virtual void setAlternateFeedDetails(const char* title, const char* feedUrl) = 0; + + virtual WebString getErrorPage(int errorCode, const char* errorMessage, const char* url) = 0; + + virtual void willDeferLoading() = 0; + virtual void didResumeLoading() = 0; + + // Headers is a list of alternating key and value. + virtual void setMetaHeaders(const ScopeArray<WebString>& headers, unsigned int headersSize) = 0; + + virtual void needMoreData() = 0; + virtual void handleWebInspectorMessageToFrontend(int id, const char* message, int length) = 0; + + virtual bool hasPendingScrollOrZoomEvent() const = 0; + virtual Platform::IntRect userInterfaceBlittedDestinationRect() const = 0; + virtual Platform::IntRect userInterfaceBlittedVisibleContentsRect() const = 0; + + virtual void resetBitmapZoomScale(double scale) = 0; + virtual void animateBlockZoom(const Platform::FloatPoint& finalPoint, double finalScale) = 0; + + virtual void setPreventsScreenIdleDimming(bool noDimming) = 0; + virtual void authenticationChallenge(const unsigned short* realm, unsigned int realmLength, WebString& username, WebString& password) = 0; + + virtual bool shouldPluginEnterFullScreen() = 0; + virtual void didPluginEnterFullScreen() = 0; + virtual void didPluginExitFullScreen() = 0; + virtual void onPluginStartBackgroundPlay() = 0; + virtual void onPluginStopBackgroundPlay() = 0; + virtual bool lockOrientation(bool landscape) = 0; + virtual void unlockOrientation() = 0; + virtual bool isActive() const = 0; + virtual void requestWebGLPermission(const WebString&) = 0; + + virtual void setToolTip(WebString) = 0; + virtual void setStatus(WebString) = 0; + virtual bool acceptNavigationRequest(const Platform::NetworkRequest&, Platform::NavigationType) = 0; + virtual void cursorEventModeChanged(Platform::CursorEventMode) = 0; + virtual void touchEventModeChanged(Platform::TouchEventMode) = 0; + + virtual bool downloadAllowed(const char* url) = 0; + virtual void downloadRequested(const Platform::NetworkRequest&) = 0; + virtual void downloadRequested(Platform::FilterStream*, const WebString& suggestedFilename) = 0; + + virtual int fullscreenStart(const char* contextName, Platform::Graphics::Window*, unsigned x, unsigned y, unsigned width, unsigned height) = 0; + + virtual int fullscreenStop() = 0; + + virtual int fullscreenWindowSet(unsigned x, unsigned y, unsigned width, unsigned height) = 0; + + virtual void drawVerticalScrollbar() = 0; + virtual void drawHorizontalScrollbar() = 0; + virtual void populateCustomHeaders(Platform::NetworkRequest&) = 0; + + virtual void notifyWillUpdateApplicationCache() = 0; + virtual void notifyDidLoadFromApplicationCache() = 0; + + virtual void clearCookies() = 0; + virtual void clearCache() = 0; + + virtual bool hasKeyboardFocus() = 0; +}; +} // namespace WebKit +} // namespace BlackBerry + +#endif // WebPageClient_h diff --git a/Source/WebKit/blackberry/Api/WebPageGroupLoadDeferrer.cpp b/Source/WebKit/blackberry/Api/WebPageGroupLoadDeferrer.cpp new file mode 100644 index 000000000..084f2f42a --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebPageGroupLoadDeferrer.cpp @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "WebPageGroupLoadDeferrer.h" + +#include "PageGroupLoadDeferrer.h" +#include "WebPage.h" +#include "WebPage_p.h" + +namespace BlackBerry { +namespace WebKit { + +WebPageGroupLoadDeferrer::WebPageGroupLoadDeferrer(WebPage* webPage) +{ + WebCore::TimerBase::fireTimersInNestedEventLoop(); + m_pageGroupLoadDeferrer = new WebCore::PageGroupLoadDeferrer(webPage->d->m_page, true /* defer the page itself */); +} + +WebPageGroupLoadDeferrer::~WebPageGroupLoadDeferrer() +{ + delete m_pageGroupLoadDeferrer; +} + +} // namespace WebKit +} // namespace BlackBerry diff --git a/Source/WebKit/blackberry/Api/WebPageGroupLoadDeferrer.h b/Source/WebKit/blackberry/Api/WebPageGroupLoadDeferrer.h new file mode 100644 index 000000000..cb651ed9d --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebPageGroupLoadDeferrer.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebPageGroupLoadDeferrer_h +#define WebPageGroupLoadDeferrer_h + +#include "BlackBerryGlobal.h" + +namespace WebCore { +class PageGroupLoadDeferrer; +} + +namespace BlackBerry { +namespace WebKit { + +class WebPage; + +// WebPageGroupLoadDeferrer is supposed to be used in the same way as WebCore::PageGroupLoadDeferrer. +// Declare a WebPageGroupLoadDeferrer object in the scope where the page group should defer loading and DOM timers. +class BLACKBERRY_EXPORT WebPageGroupLoadDeferrer { +public: + explicit WebPageGroupLoadDeferrer(WebPage*); + ~WebPageGroupLoadDeferrer(); +private: + WebCore::PageGroupLoadDeferrer* m_pageGroupLoadDeferrer; +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // WebPageGroupLoadDeferrer_h diff --git a/Source/WebKit/blackberry/Api/WebPage_p.h b/Source/WebKit/blackberry/Api/WebPage_p.h new file mode 100644 index 000000000..e0238b6d6 --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebPage_p.h @@ -0,0 +1,517 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebPage_p_h +#define WebPage_p_h + +#include "ChromeClient.h" +#if USE(ACCELERATED_COMPOSITING) +#include "LayerRenderer.h" +#endif +#include "PageClientBlackBerry.h" +#include "PlatformMouseEvent.h" +#include "ScriptSourceCode.h" +#include "Timer.h" +#include "ViewportArguments.h" +#include "WebPage.h" +#include "WebSettings.h" + +#include <BlackBerryPlatformMessage.h> + +namespace WebCore { +class DOMWrapperWorld; +class Document; +class Frame; +class FrameView; +class GeolocationControllerClientBlackBerry; +class JavaScriptDebuggerBlackBerry; +class KURL; +class Node; +class Page; +class PluginView; +class RenderLayer; +class RenderObject; +class ScrollView; +class TransformationMatrix; +template<typename T> class Timer; +} + +namespace BlackBerry { +namespace WebKit { + +class BackingStore; +class BackingStoreClient; +class BackingStoreTile; +class DumpRenderTreeClient; +class InPageSearchManager; +class InputHandler; +class InRegionScrollableArea; +class SelectionHandler; +class TouchEventHandler; +class WebPageClient; + +#if USE(ACCELERATED_COMPOSITING) +class FrameLayers; +class WebPageCompositor; +#endif + +// In the client code, there is screen size and viewport. +// In WebPagePrivate, the screen size is called the transformedViewportSize, +// the viewport position is called the transformedScrollPosition, +// and the viewport size is called the transformedActualVisibleSize. +class WebPagePrivate : public PageClientBlackBerry, public WebSettingsDelegate, public Platform::GuardedPointerBase { +public: + enum ViewMode { Mobile, Desktop, FixedDesktop }; + enum LoadState { None /* on instantiation of page */, Provisional, Committed, Finished, Failed }; + + WebPagePrivate(WebPage*, WebPageClient*, const WebCore::IntRect&); + virtual ~WebPagePrivate(); + + void init(const WebString& pageGroupName); + bool handleMouseEvent(WebCore::PlatformMouseEvent&); + bool handleWheelEvent(WebCore::PlatformWheelEvent&); + + void load(const char* url, const char* networkToken, const char* method, Platform::NetworkRequest::CachePolicy, const char* data, size_t dataLength, const char* const* headers, size_t headersLength, bool isInitial, bool mustHandleInternally = false, bool forceDownload = false, const char* overrideContentType = ""); + void loadString(const char* string, const char* baseURL, const char* mimeType, const char* failingURL = 0); + bool executeJavaScript(const char* script, JavaScriptDataType& returnType, WebString& returnValue); + bool executeJavaScriptInIsolatedWorld(const WebCore::ScriptSourceCode&, JavaScriptDataType& returnType, WebString& returnValue); + + void stopCurrentLoad(); + void prepareToDestroy(); + + LoadState loadState() const { return m_loadState; } + bool isLoading() const { return m_loadState == WebPagePrivate::Provisional || m_loadState == WebPagePrivate::Committed; } + + // Called from within WebKit via FrameLoaderClientBlackBerry. + void setLoadState(LoadState); + + // Clamp the scale. + double clampedScale(double scale) const; + + // Determine if we should zoom, clamping the scale parameter if required. + bool shouldZoomAboutPoint(double scale, const WebCore::FloatPoint& anchor, bool enforeScaleClamping, double* clampedScale); + + // Scale the page to the given scale and anchor about the point which is specified in untransformed content coordinates. + bool zoomAboutPoint(double scale, const WebCore::FloatPoint& anchor, bool enforceScaleClamping = true, bool forceRendering = false, bool isRestoringZoomLevel = false); + bool scheduleZoomAboutPoint(double scale, const WebCore::FloatPoint& anchor, bool enforceScaleClamping = true, bool forceRendering = false); + void unscheduleZoomAboutPoint(); + WebCore::IntPoint calculateReflowedScrollPosition(const WebCore::FloatPoint& anchorOffset, double inverseScale); + void setTextReflowAnchorPoint(const Platform::IntPoint& focalPoint); + + void schedulePinchZoomAboutPoint(double scale, const WebCore::IntPoint& anchor); + + // Perform actual zoom for block zoom. + void zoomBlock(); + + // Called by the backing store as well as the method below. + void requestLayoutIfNeeded() const; + void setNeedsLayout(); + + WebCore::IntPoint scrollPosition() const; + WebCore::IntPoint maximumScrollPosition() const; + void setScrollPosition(const WebCore::IntPoint&); + bool scrollBy(int deltaX, int deltaY, bool scrollMainFrame = true); + + void enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling(WebCore::Node*); + std::vector<Platform::ScrollViewBase> inRegionScrollableAreasForPoint(const Platform::IntPoint&); + void notifyInRegionScrollStatusChanged(bool status); + void setScrollOriginPoint(const Platform::IntPoint&); + void setHasInRegionScrollableAreas(bool); + + // The actual visible size as reported by the client, but in WebKit coordinates. + WebCore::IntSize actualVisibleSize() const; + + // The viewport size is the same as the client's window size, but in webkit coordinates. + WebCore::IntSize viewportSize() const; + + // Modifies the zoomToFit algorithm logic to construct a scale such that the viewportSize above is equal to this size. + bool hasVirtualViewport() const; + bool isUserScalable() const { return m_userScalable; } + void setUserScalable(bool userScalable) { m_userScalable = userScalable; } + + // Sets default layout size without doing layout or marking as needing layout. + void setDefaultLayoutSize(const WebCore::IntSize&); + + // Updates WebCore when the viewportSize() or actualVisibleSize() change. + void updateViewportSize(bool setFixedReportedSize = true, bool sendResizeEvent = true); + + WebCore::FloatPoint centerOfVisibleContentsRect() const; + WebCore::IntRect visibleContentsRect() const; + WebCore::IntSize contentsSize() const; + WebCore::IntSize absoluteVisibleOverflowSize() const; + + // Virtual functions inherited from PageClientBlackBerry. + virtual void setCursor(WebCore::PlatformCursorHandle); + virtual Platform::NetworkStreamFactory* networkStreamFactory(); + virtual Platform::Graphics::Window* platformWindow() const; + virtual void setPreventsScreenDimming(bool preventDimming); + virtual void showVirtualKeyboard(bool showKeyboard); + virtual void ensureContentVisible(bool centerInView = true); + virtual void zoomToContentRect(const WebCore::IntRect&); + virtual void registerPlugin(WebCore::PluginView*, bool); + virtual void notifyPageOnLoad(); + virtual bool shouldPluginEnterFullScreen(WebCore::PluginView*, const char*); + virtual void didPluginEnterFullScreen(WebCore::PluginView*, const char*); + virtual void didPluginExitFullScreen(WebCore::PluginView*, const char*); + virtual void onPluginStartBackgroundPlay(WebCore::PluginView*, const char*); + virtual void onPluginStopBackgroundPlay(WebCore::PluginView*, const char*); + virtual bool lockOrientation(bool landscape); + virtual void unlockOrientation(); + virtual int orientation() const; + virtual double currentZoomFactor() const; + virtual int showAlertDialog(WebPageClient::AlertType atype); + virtual bool isActive() const; + + // Called from within WebKit via ChromeClientBlackBerry. + void enterFullscreenForNode(WebCore::Node*); + void exitFullscreenForNode(WebCore::Node*); + void contentsSizeChanged(const WebCore::IntSize&); + void overflowExceedsContentsSize() { m_overflowExceedsContentsSize = true; } + void layoutFinished(); + void setNeedTouchEvents(bool); + + // Called according to our heuristic or from setLoadState depending on whether we have a virtual viewport. + void zoomToInitialScaleOnLoad(); + + // Various scale factors. + double currentScale() const { return m_transformationMatrix->m11(); } + double zoomToFitScale() const; + double initialScale() const; + void setInitialScale(double scale) { m_initialScale = scale; } + double minimumScale() const + { + return (m_minimumScale > zoomToFitScale() && m_minimumScale <= maximumScale()) ? m_minimumScale : zoomToFitScale(); + } + + void setMinimumScale(double scale) { m_minimumScale = scale; } + double maximumScale() const; + void setMaximumScale(double scale) { m_maximumScale = scale; } + void resetScales(); + + // Note: to make this reflow width transform invariant just use + // transformedActualVisibleSize() here instead! + int reflowWidth() const { return actualVisibleSize().width(); } + + // These methods give the real geometry of the device given the currently set transform. + WebCore::IntPoint transformedScrollPosition() const; + WebCore::IntPoint transformedMaximumScrollPosition() const; + WebCore::IntSize transformedActualVisibleSize() const; + WebCore::IntSize transformedViewportSize() const; + WebCore::IntRect transformedVisibleContentsRect() const; + WebCore::IntSize transformedContentsSize() const; + + // Generic conversions of points, rects, relative to and from contents and viewport. + WebCore::IntPoint mapFromContentsToViewport(const WebCore::IntPoint&) const; + WebCore::IntPoint mapFromViewportToContents(const WebCore::IntPoint&) const; + WebCore::IntRect mapFromContentsToViewport(const WebCore::IntRect&) const; + WebCore::IntRect mapFromViewportToContents(const WebCore::IntRect&) const; + + // Generic conversions of points, rects, relative to and from transformed contents and transformed viewport. + WebCore::IntPoint mapFromTransformedContentsToTransformedViewport(const WebCore::IntPoint&) const; + WebCore::IntPoint mapFromTransformedViewportToTransformedContents(const WebCore::IntPoint&) const; + WebCore::IntRect mapFromTransformedContentsToTransformedViewport(const WebCore::IntRect&) const; + WebCore::IntRect mapFromTransformedViewportToTransformedContents(const WebCore::IntRect&) const; + + // Generic conversions of points, rects, and sizes to and from transformed coordinates. + WebCore::IntPoint mapToTransformed(const WebCore::IntPoint&) const; + WebCore::FloatPoint mapToTransformedFloatPoint(const WebCore::FloatPoint&) const; + WebCore::IntPoint mapFromTransformed(const WebCore::IntPoint&) const; + WebCore::FloatPoint mapFromTransformedFloatPoint(const WebCore::FloatPoint&) const; + WebCore::FloatRect mapFromTransformedFloatRect(const WebCore::FloatRect&) const; + WebCore::IntSize mapToTransformed(const WebCore::IntSize&) const; + WebCore::IntSize mapFromTransformed(const WebCore::IntSize&) const; + WebCore::IntRect mapToTransformed(const WebCore::IntRect&) const; + void clipToTransformedContentsRect(WebCore::IntRect&) const; + WebCore::IntRect mapFromTransformed(const WebCore::IntRect&) const; + bool transformedPointEqualsUntransformedPoint(const WebCore::IntPoint& transformedPoint, const WebCore::IntPoint& untransformedPoint); + + // Notification methods that deliver changes to the real geometry of the device as specified above. + void notifyTransformChanged(); + void notifyTransformedContentsSizeChanged(); + void notifyTransformedScrollChanged(); + + void assignFocus(Platform::FocusDirection); + Platform::IntRect focusNodeRect(); + WebCore::IntRect getRecursiveVisibleWindowRect(WebCore::ScrollView*, bool noClipOfMainFrame = false); + + WebCore::IntPoint frameOffset(const WebCore::Frame*) const; + + WebCore::Node* bestNodeForZoomUnderPoint(const WebCore::IntPoint&); + WebCore::Node* bestChildNodeForClickRect(WebCore::Node* parentNode, const WebCore::IntRect& clickRect); + WebCore::Node* nodeForZoomUnderPoint(const WebCore::IntPoint&); + WebCore::Node* adjustedBlockZoomNodeForZoomLimits(WebCore::Node*); + WebCore::IntRect rectForNode(WebCore::Node*); + WebCore::IntRect blockZoomRectForNode(WebCore::Node*); + WebCore::IntRect adjustRectOffsetForFrameOffset(const WebCore::IntRect&, const WebCore::Node*); + bool compareNodesForBlockZoom(WebCore::Node* n1, WebCore::Node* n2); + double newScaleForBlockZoomRect(const WebCore::IntRect&, double oldScale, double margin); + double maxBlockZoomScale() const; + + // Plugin Methods. + void notifyPluginRectChanged(int id, const WebCore::IntRect& rectChanged); + + // Context Methods. + ActiveNodeContext activeNodeContext(TargetDetectionStrategy); + PassRefPtr<WebCore::Node> contextNode(TargetDetectionStrategy); + +#if ENABLE(VIEWPORT_REFLOW) + void toggleTextReflowIfEnabledForBlockZoomOnly(bool shouldEnableTextReflow = false); +#endif + + void selectionChanged(WebCore::Frame*); + + void updateDelegatedOverlays(bool dispatched = false); + + void updateCursor(); + + void onInputLocaleChanged(bool isRTL); + + ViewMode viewMode() const { return m_viewMode; } + bool setViewMode(ViewMode); // Returns true if the change requires re-layout. + + void setShouldUseFixedDesktopMode(bool b) { m_shouldUseFixedDesktopMode = b; } + + bool useFixedLayout() const; + WebCore::IntSize fixedLayoutSize(bool snapToIncrement = false) const; + + // ZoomToFitOnLoad can lead to a large recursion depth in FrameView::layout() as we attempt + // to determine the zoom scale factor so as to have the content of the page fit within the + // area of the frame. From observation, we can bail out after a recursion depth of 10 and + // still have reasonable results. + bool didLayoutExceedMaximumIterations() const { return m_nestedLayoutFinishedCount > 10; } + + void clearFocusNode(); + WebCore::Frame* focusedOrMainFrame() const; + WebCore::Frame* mainFrame() const { return m_mainFrame; } + + bool scrollNodeRecursively(WebCore::Node* originalNode, const WebCore::IntSize& delta); + bool scrollRenderer(WebCore::RenderObject* renderer, const WebCore::IntSize& delta); + void adjustScrollDelta(const WebCore::IntPoint& maxOffset, const WebCore::IntPoint& currentOffset, WebCore::IntSize& delta) const; + + bool canScrollRenderBox(WebCore::RenderBox*); + bool canScrollInnerFrame(WebCore::Frame*) const; + +#if ENABLE(EVENT_MODE_METATAGS) + void didReceiveCursorEventMode(WebCore::CursorEventMode); + void didReceiveTouchEventMode(WebCore::TouchEventMode); +#endif + + void dispatchViewportPropertiesDidChange(const WebCore::ViewportArguments&); + WebCore::IntSize recomputeVirtualViewportFromViewportArguments(); + + void resetBlockZoom(); + + void zoomAboutPointTimerFired(WebCore::Timer<WebPagePrivate>*); + bool shouldSendResizeEvent(); + void scrollEventTimerFired(WebCore::Timer<WebPagePrivate>*); + void resizeEventTimerFired(WebCore::Timer<WebPagePrivate>*); + + // If this url should be handled as a pattern, returns the pattern + // otherwise, returns an empty string. + String findPatternStringForUrl(const WebCore::KURL&) const; + + void suspendBackingStore(); + void resumeBackingStore(); + + void setShouldResetTilesWhenShown(bool flag) { m_shouldResetTilesWhenShown = flag; } + bool shouldResetTilesWhenShown() const { return m_shouldResetTilesWhenShown; } + + void setScreenOrientation(int); + + // Scroll and/or zoom so that the WebPage fits the new actual + // visible size. + void setViewportSize(const WebCore::IntSize& transformedActualVisibleSize, bool ensureFocusElementVisible); + void screenRotated(); // Helper method for setViewportSize(). + + void scheduleDeferrableTimer(WebCore::Timer<WebPagePrivate>*, double timeOut); + void unscheduleAllDeferrableTimers(); + void willDeferLoading(); + void didResumeLoading(); + + // Returns true if the escape key handler should zoom. + bool shouldZoomOnEscape() const; + + WebCore::TransformationMatrix* transformationMatrix() const + { + return m_transformationMatrix; + } + +#if USE(ACCELERATED_COMPOSITING) + // WebKit thread. + bool needsOneShotDrawingSynchronization(); + void rootLayerCommitTimerFired(WebCore::Timer<WebPagePrivate>*); + bool commitRootLayerIfNeeded(); + WebCore::LayerRenderingResults lastCompositingResults() const; + + // WebKit thread, plumbed through from ChromeClientBlackBerry. + void setRootLayerWebKitThread(WebCore::Frame*, WebCore::LayerWebKitThread*); + void setNeedsOneShotDrawingSynchronization(); + void scheduleRootLayerCommit(); + + // Thread safe. + void resetCompositingSurface(); + void drawLayersOnCommit(); // Including backing store blit. + bool drawSubLayers(const WebCore::IntRect& dstRect, const WebCore::FloatRect& contents); + bool drawSubLayers(); // Draw them at last known position. + + // Compositing thread. + void setRootLayerCompositingThread(WebCore::LayerCompositingThread*); + void commitRootLayer(const WebCore::IntRect&, const WebCore::IntSize&); + void setIsAcceleratedCompositingActive(bool); + void destroyCompositor(); + void syncDestroyCompositorOnCompositingThread(); + void destroyLayerResources(); + void suspendRootLayerCommit(); + void resumeRootLayerCommit(); + void blitVisibleContents(); +#endif + + bool dispatchTouchEventToFullScreenPlugin(WebCore::PluginView*, const Platform::TouchEvent&); + bool dispatchTouchPointAsMouseEventToFullScreenPlugin(WebCore::PluginView*, const Platform::TouchPoint&); + bool dispatchMouseEventToFullScreenPlugin(WebCore::PluginView*, const Platform::MouseEvent&); + + BackingStoreClient* backingStoreClientForFrame(const WebCore::Frame*) const; + void addBackingStoreClientForFrame(const WebCore::Frame*, BackingStoreClient*); + void removeBackingStoreClientForFrame(const WebCore::Frame*); + + // Clean up any document related data we might be holding. + void clearDocumentData(const WebCore::Document*); + + static WebCore::RenderLayer* enclosingPositionedAncestorOrSelfIfPositioned(WebCore::RenderLayer*); + static WebCore::RenderLayer* enclosingFixedPositionedAncestorOrSelfIfFixedPositioned(WebCore::RenderLayer*); + + static WebCore::IntSize defaultMaxLayoutSize(); + + WebPage* m_webPage; + WebPageClient* m_client; + WebCore::Page* m_page; + WebCore::Frame* m_mainFrame; + RefPtr<WebCore::Node> m_currentContextNode; + WebSettings* m_webSettings; + +#if ENABLE(JAVASCRIPT_DEBUGGER) + OwnPtr<WebCore::JavaScriptDebuggerBlackBerry> m_scriptDebugger; +#endif + + bool m_visible; + bool m_shouldResetTilesWhenShown; + bool m_userScalable; + bool m_userPerformedManualZoom; + bool m_userPerformedManualScroll; + bool m_contentsSizeChanged; + bool m_overflowExceedsContentsSize; + bool m_resetVirtualViewportOnCommitted; + bool m_shouldUseFixedDesktopMode; + bool m_needTouchEvents; + int m_preventIdleDimmingCount; + +#if ENABLE(TOUCH_EVENTS) + bool m_preventDefaultOnTouchStart; +#endif + unsigned m_nestedLayoutFinishedCount; + WebCore::IntSize m_previousContentsSize; + int m_actualVisibleWidth; + int m_actualVisibleHeight; + int m_virtualViewportWidth; + int m_virtualViewportHeight; + WebCore::IntSize m_defaultLayoutSize; + WebCore::ViewportArguments m_viewportArguments; // We keep this around since we may need to re-evaluate the arguments on rotation. + bool m_didRestoreFromPageCache; + ViewMode m_viewMode; + LoadState m_loadState; + WebCore::TransformationMatrix* m_transformationMatrix; + BackingStore* m_backingStore; + BackingStoreClient* m_backingStoreClient; + InPageSearchManager* m_inPageSearchManager; + InputHandler* m_inputHandler; + SelectionHandler* m_selectionHandler; + TouchEventHandler* m_touchEventHandler; + +#if ENABLE(EVENT_MODE_METATAGS) + WebCore::CursorEventMode m_cursorEventMode; + WebCore::TouchEventMode m_touchEventMode; +#endif + + Platform::BlackBerryCursor m_currentCursor; + + DumpRenderTreeClient* m_dumpRenderTree; + + double m_initialScale; + double m_minimumScale; + double m_maximumScale; + + // Block zoom animation data. + WebCore::FloatPoint m_finalBlockPoint; + WebCore::FloatPoint m_finalBlockPointReflowOffset; + double m_blockZoomFinalScale; + RefPtr<WebCore::Node> m_currentPinchZoomNode; + WebCore::FloatPoint m_anchorInNodeRectRatio; + RefPtr<WebCore::Node> m_currentBlockZoomNode; + RefPtr<WebCore::Node> m_currentBlockZoomAdjustedNode; + bool m_shouldReflowBlock; + + // Delayed zoomAboutPoint. + OwnPtr<WebCore::Timer<WebPagePrivate> > m_delayedZoomTimer; + struct { + double scale; + WebCore::FloatPoint anchor; + bool enforceScaleClamping; + bool forceRendering; + } m_delayedZoomArguments; + + double m_lastUserEventTimestamp; // Used to detect user scrolling. + + WebCore::PlatformMouseEvent m_lastMouseEvent; + bool m_pluginMouseButtonPressed; // Used to track mouse button for full screen plugins. + bool m_pluginMayOpenNewTab; + + WebCore::GeolocationControllerClientBlackBerry* m_geolocationClient; + + HashSet<WebCore::PluginView*> m_pluginViews; + + RefPtr<WebCore::Node> m_inRegionScrollStartingNode; + +#if USE(ACCELERATED_COMPOSITING) + bool m_isAcceleratedCompositingActive; + OwnPtr<FrameLayers> m_frameLayers; // WebKit thread only. + OwnPtr<WebPageCompositor> m_compositor; // Compositing thread only. + OwnPtr<WebCore::Timer<WebPagePrivate> > m_rootLayerCommitTimer; + bool m_needsOneShotDrawingSynchronization; + bool m_needsCommit; + bool m_suspendRootLayerCommit; +#endif + + int m_pendingOrientation; + + RefPtr<WebCore::Node> m_fullscreenVideoNode; + RefPtr<WebCore::PluginView> m_fullScreenPluginView; + + typedef HashMap<const WebCore::Frame*, BackingStoreClient*> BackingStoreClientForFrameMap; + BackingStoreClientForFrameMap m_backingStoreClientForFrameMap; + + // WebSettingsDelegate methods. + virtual void didChangeSettings(WebSettings*); + + RefPtr<WebCore::DOMWrapperWorld> m_isolatedWorld; + bool m_hasInRegionScrollableAreas; + bool m_updateDelegatedOverlaysDispatched; +}; +} +} + +#endif // WebPage_p_h diff --git a/Source/WebKit/blackberry/Api/WebSettings.cpp b/Source/WebKit/blackberry/Api/WebSettings.cpp new file mode 100644 index 000000000..960964cd8 --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebSettings.cpp @@ -0,0 +1,816 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "WebSettings.h" + +#include "WebSettings_p.h" + +#include "WebString.h" +#include <Base64.h> +#include <Color.h> +#include <PageCache.h> +#include <wtf/HashSet.h> +#include <wtf/Vector.h> + +namespace BlackBerry { +namespace WebKit { + +DEFINE_STATIC_LOCAL(String, BlackBerryAllowCrossSiteRequests, ("BlackBerryAllowCrossSiteRequests")); +DEFINE_STATIC_LOCAL(String, BlackBerryBackgroundColor, ("BlackBerryBackgroundColor")); +DEFINE_STATIC_LOCAL(String, BlackBerryCookiesEnabled, ("BlackBerryCookiesEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryDirectRenderingToWindowEnabled, ("BlackBerryDirectRenderingToWindowEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryDrawBorderWhileLoadingImages, ("BlackBerryDrawBorderWhileLoadingImages")); +DEFINE_STATIC_LOCAL(String, BlackBerryEmailModeEnabled, ("BlackBerryEmailModeEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryGetFocusNodeContextEnabled, ("BlackBerryGetFocusNodeContextEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryHandlePatternURLs, ("BlackBerryHandlePatternURLs")); +DEFINE_STATIC_LOCAL(String, BlackBerryInitialScale, ("BlackBerryInitialScale")); +DEFINE_STATIC_LOCAL(String, BlackBerryLinksHandledExternallyEnabled, ("BlackBerryLinksHandledExternallyEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryMaxPluginInstances, ("BlackBerryMaxPluginInstances")); +DEFINE_STATIC_LOCAL(String, BlackBerryOverZoomColor, ("BlackBerryOverZoomColor")); +DEFINE_STATIC_LOCAL(String, BlackBerryRenderAnimationsOnScrollOrZoomEnabled, ("BlackBerryRenderAnimationsOnScrollOrZoomEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryScrollbarsEnabled, ("BlackBerryScrollbarsEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryTextReflowMode, ("BlackBerryTextReflowMode")); +DEFINE_STATIC_LOCAL(String, BlackBerryUseRTLWritingDirection, ("BlackBerryUseRTLWritingDirection")); +DEFINE_STATIC_LOCAL(String, BlackBerryUseWebKitCache, ("BlackBerryUseWebKitCache")); +DEFINE_STATIC_LOCAL(String, BlackBerryUserAgentString, ("BlackBerryUserAgentString")); +DEFINE_STATIC_LOCAL(String, BlackBerryUserScalableEnabled, ("BlackBerryUserScalableEnabled")); +DEFINE_STATIC_LOCAL(String, BlackBerryViewportWidth, ("BlackBerryViewportWidth")); +DEFINE_STATIC_LOCAL(String, BlackBerryZoomToFitOnLoadEnabled, ("BlackBerryZoomToFitOnLoadEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitDatabasePath, ("WebKitDatabasePath")); +DEFINE_STATIC_LOCAL(String, WebKitDatabasesEnabled, ("WebKitDatabasesEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitDefaultFixedFontSize, ("WebKitDefaultFixedFontSize")); +DEFINE_STATIC_LOCAL(String, WebKitDefaultFontSize, ("WebKitDefaultFontSize")); +DEFINE_STATIC_LOCAL(String, WebKitDefaultTextEncodingName, ("WebKitDefaultTextEncodingName")); +DEFINE_STATIC_LOCAL(String, WebKitDownloadableBinaryFontsEnabled, ("WebKitDownloadableBinaryFontsEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitFirstScheduledLayoutDelay, ("WebKitFirstScheduledLayoutDelay")); +DEFINE_STATIC_LOCAL(String, WebKitFixedFontFamily, ("WebKitFixedFontFamily")); +DEFINE_STATIC_LOCAL(String, WebKitFrameFlatteningEnabled, ("WebKitFrameFlatteningEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitGeolocationEnabled, ("WebKitGeolocationEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitJavaScriptCanOpenWindowsAutomaticallyEnabled, ("WebKitJavaScriptCanOpenWindowsAutomaticallyEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitJavaScriptEnabled, ("WebKitJavaScriptEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitLoadsImagesAutomatically, ("WebKitLoadsImagesAutomatically")); +DEFINE_STATIC_LOCAL(String, WebKitLocalStorageEnabled, ("WebKitLocalStorageEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitLocalStoragePath, ("WebKitLocalStoragePath")); +DEFINE_STATIC_LOCAL(String, WebKitLocalStorageQuota, ("WebKitLocalStorageQuota")); +DEFINE_STATIC_LOCAL(String, WebKitMaximumPagesInCache, ("WebKitMaximumPagesInCache")); +DEFINE_STATIC_LOCAL(String, WebKitMinimumFontSize, ("WebKitMinimumFontSize")); +DEFINE_STATIC_LOCAL(String, WebKitOfflineWebApplicationCacheEnabled, ("WebKitOfflineWebApplicationCacheEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitOfflineWebApplicationCachePath, ("WebKitOfflineWebApplicationCachePath")); +DEFINE_STATIC_LOCAL(String, WebKitPageGroupName, ("WebKitPageGroupName")); +DEFINE_STATIC_LOCAL(String, WebKitPluginsEnabled, ("WebKitPluginsEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitPrivateBrowsingEnabled, ("WebKitPrivateBrowsingEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitSansSeriffFontFamily, ("WebKitSansSeriffFontFamily")); +DEFINE_STATIC_LOCAL(String, WebKitSeriffFontFamily, ("WebKitSeriffFontFamily")); +DEFINE_STATIC_LOCAL(String, WebKitStandardFontFamily, ("WebKitStandardFontFamily")); +DEFINE_STATIC_LOCAL(String, WebKitUserStyleSheet, ("WebKitUserStyleSheet")); +DEFINE_STATIC_LOCAL(String, WebKitUserStyleSheetLocation, ("WebKitUserStyleSheetLocation")); +DEFINE_STATIC_LOCAL(String, WebKitWebSocketsEnabled, ("WebKitWebSocketsEnabled")); +DEFINE_STATIC_LOCAL(String, WebKitXSSAuditorEnabled, ("WebKitXSSAuditorEnabled")); +DEFINE_STATIC_LOCAL(String, SpatialNavigationEnabled, ("SpatialNavigationEnabled")); + +// FIXME: We should consider moving all the mime type code into its own object. + +typedef HashMap<String, WebString> MIMETypeAssociationMap; + +static const MIMETypeAssociationMap& mimeTypeAssociationMap() +{ + static MIMETypeAssociationMap* mimeTypeMap = 0; + if (mimeTypeMap) + return *mimeTypeMap; + + mimeTypeMap = new MIMETypeAssociationMap; + mimeTypeMap->add("image/x-ms-bmp", "image/bmp"); + mimeTypeMap->add("image/x-windows-bmp", "image/bmp"); + mimeTypeMap->add("image/x-bmp", "image/bmp"); + mimeTypeMap->add("image/x-bitmap", "image/bmp"); + mimeTypeMap->add("image/x-ms-bitmap", "image/bmp"); + mimeTypeMap->add("image/jpg", "image/jpeg"); + mimeTypeMap->add("image/pjpeg", "image/jpeg"); + mimeTypeMap->add("image/x-png", "image/png"); + mimeTypeMap->add("image/vnd.rim.png", "image/png"); + mimeTypeMap->add("image/ico", "image/vnd.microsoft.icon"); + mimeTypeMap->add("image/icon", "image/vnd.microsoft.icon"); + mimeTypeMap->add("text/ico", "image/vnd.microsoft.icon"); + mimeTypeMap->add("application/ico", "image/vnd.microsoft.icon"); + mimeTypeMap->add("image/x-icon", "image/vnd.microsoft.icon"); + mimeTypeMap->add("audio/vnd.qcelp", "audio/qcelp"); + mimeTypeMap->add("audio/qcp", "audio/qcelp"); + mimeTypeMap->add("audio/vnd.qcp", "audio/qcelp"); + mimeTypeMap->add("audio/wav", "audio/x-wav"); + mimeTypeMap->add("audio/mid", "audio/midi"); + mimeTypeMap->add("audio/sp-midi", "audio/midi"); + mimeTypeMap->add("audio/x-mid", "audio/midi"); + mimeTypeMap->add("audio/x-midi", "audio/midi"); + mimeTypeMap->add("audio/x-mpeg", "audio/mpeg"); + mimeTypeMap->add("audio/mp3", "audio/mpeg"); + mimeTypeMap->add("audio/x-mp3", "audio/mpeg"); + mimeTypeMap->add("audio/mpeg3", "audio/mpeg"); + mimeTypeMap->add("audio/x-mpeg3", "audio/mpeg"); + mimeTypeMap->add("audio/mpg3", "audio/mpeg"); + mimeTypeMap->add("audio/mpg", "audio/mpeg"); + mimeTypeMap->add("audio/x-mpg", "audio/mpeg"); + mimeTypeMap->add("audio/m4a", "audio/mp4"); + mimeTypeMap->add("audio/x-m4a", "audio/mp4"); + mimeTypeMap->add("audio/x-mp4", "audio/mp4"); + mimeTypeMap->add("audio/x-aac", "audio/aac"); + mimeTypeMap->add("audio/x-amr", "audio/amr"); + mimeTypeMap->add("audio/mpegurl", "audio/x-mpegurl"); + mimeTypeMap->add("video/3gp", "video/3gpp"); + mimeTypeMap->add("video/avi", "video/x-msvideo"); + mimeTypeMap->add("video/x-m4v", "video/mp4"); + mimeTypeMap->add("video/x-quicktime", "video/quicktime"); + mimeTypeMap->add("application/java", "application/java-archive"); + mimeTypeMap->add("application/x-java-archive", "application/java-archive"); + mimeTypeMap->add("application/x-zip-compressed", "application/zip"); + + return *mimeTypeMap; +} + +static HashSet<String>* s_supportedObjectMIMETypes; + +WebSettingsPrivate::WebSettingsPrivate() + : impl(0) + , delegate(0) + , sender(0) + , copyOnWrite(true) +{ +} + +WebSettings::WebSettings() +{ + m_private = new WebSettingsPrivate(); +} + +WebSettings::WebSettings(const WebSettings& otherSettings) +{ + m_private->impl = otherSettings.m_private->impl; +} + +WebSettings::~WebSettings() +{ + if (!m_private->copyOnWrite) { + delete m_private->impl; + m_private->impl = 0; + } + delete m_private; + m_private = 0; +} + +void WebSettings::setDelegate(WebSettingsDelegate* delegate) +{ + m_private->delegate = delegate; + m_private->sender = this; +} + +WebSettingsDelegate* WebSettings::delegate() +{ + return m_private->delegate; +} + +WebSettings* WebSettings::createFromStandardSettings(WebSettingsDelegate* delegate) +{ + WebSettings* settings = new WebSettings(); + settings->m_private->impl = standardSettings()->m_private->impl; + settings->m_private->delegate = delegate; + settings->m_private->sender = settings; + if (delegate) + delegate->didChangeSettings(settings); + + return settings; +} + +WebSettings* WebSettings::standardSettings() +{ + static WebSettings *settings = 0; + if (settings) + return settings; + + settings = new WebSettings; + settings->m_private->impl = new WebSettingsPrivate::WebSettingsPrivateImpl(); + settings->m_private->copyOnWrite = false; + settings->m_private->setUnsigned(BlackBerryBackgroundColor, WebCore::Color::white); + settings->m_private->setBoolean(BlackBerryCookiesEnabled, true); + settings->m_private->setDouble(BlackBerryInitialScale, -1); + settings->m_private->setUnsigned(BlackBerryMaxPluginInstances, 1); + settings->m_private->setUnsigned(BlackBerryOverZoomColor, WebCore::Color::white); + settings->m_private->setBoolean(BlackBerryScrollbarsEnabled, true); + + // FIXME: We should detect whether we are embedded in a browser or an email client and default to TextReflowEnabledOnlyForBlockZoom and TextReflowEnabled, respectively. + settings->m_private->setTextReflowMode(BlackBerryTextReflowMode, TextReflowDisabled); + + settings->m_private->setBoolean(BlackBerryUserScalableEnabled, true); + settings->m_private->setBoolean(BlackBerryUseWebKitCache, true); + settings->m_private->setBoolean(BlackBerryZoomToFitOnLoadEnabled, true); + settings->m_private->setInteger(WebKitDefaultFontSize, 16); + settings->m_private->setInteger(WebKitDefaultFixedFontSize, 13); + settings->m_private->setInteger(WebKitMinimumFontSize, 8); + settings->m_private->setString(WebKitDefaultTextEncodingName, "iso-8859-1"); + settings->m_private->setInteger(WebKitFirstScheduledLayoutDelay, 250); // Match Document::cLayoutScheduleThreshold. + settings->m_private->setBoolean(WebKitJavaScriptEnabled, true); + settings->m_private->setBoolean(WebKitLoadsImagesAutomatically, true); + settings->m_private->setBoolean(WebKitDownloadableBinaryFontsEnabled, true); + settings->m_private->setUnsignedLongLong(WebKitLocalStorageQuota, 5 * 1024 * 1024); + settings->m_private->setInteger(WebKitMaximumPagesInCache, 0); + settings->m_private->setBoolean(WebKitWebSocketsEnabled, true); + settings->m_private->setString(WebKitFixedFontFamily, "Courier New"); + settings->m_private->setString(WebKitSansSeriffFontFamily, "Arial"); + settings->m_private->setString(WebKitSeriffFontFamily, "Times New Roman"); + settings->m_private->setString(WebKitStandardFontFamily, "Times New Roman"); + settings->m_private->setBoolean(SpatialNavigationEnabled, false); + + return settings; +} + +void WebSettings::addSupportedObjectPluginMIMEType(const char* type) +{ + if (!s_supportedObjectMIMETypes) + s_supportedObjectMIMETypes = new HashSet<String>; + + s_supportedObjectMIMETypes->add(type); +} + +bool WebSettings::isSupportedObjectMIMEType(const WebString& mimeType) +{ + if (mimeType.isEmpty()) + return false; + + if (!s_supportedObjectMIMETypes) + return false; + + return s_supportedObjectMIMETypes->contains(getNormalizedMIMEType(mimeType)); +} + +WebString WebSettings::getNormalizedMIMEType(const WebString& type) +{ + MIMETypeAssociationMap::const_iterator i = mimeTypeAssociationMap().find(type); + + return i == mimeTypeAssociationMap().end() ? type : i->second; +} + +bool WebSettings::xssAuditorEnabled() const +{ + return m_private->getBoolean(WebKitXSSAuditorEnabled); +} + +void WebSettings::setXSSAuditorEnabled(bool enabled) +{ + return m_private->setBoolean(WebKitXSSAuditorEnabled, enabled); +} + +bool WebSettings::loadsImagesAutomatically() const +{ + return m_private->getBoolean(WebKitLoadsImagesAutomatically); +} + +void WebSettings::setLoadsImagesAutomatically(bool enabled) +{ + m_private->setBoolean(WebKitLoadsImagesAutomatically, enabled); +} + +bool WebSettings::downloadableBinaryFontsEnabled() const +{ + return m_private->getBoolean(WebKitDownloadableBinaryFontsEnabled); +} + +void WebSettings::setDownloadableBinaryFontsEnabled(bool enabled) +{ + return m_private->setBoolean(WebKitDownloadableBinaryFontsEnabled, enabled); +} + +bool WebSettings::shouldDrawBorderWhileLoadingImages() const +{ + return m_private->getBoolean(BlackBerryDrawBorderWhileLoadingImages); +} + +void WebSettings::setShouldDrawBorderWhileLoadingImages(bool enabled) +{ + m_private->setBoolean(BlackBerryDrawBorderWhileLoadingImages, enabled); +} + +bool WebSettings::isJavaScriptEnabled() const +{ + return m_private->getBoolean(WebKitJavaScriptEnabled); +} + +void WebSettings::setJavaScriptEnabled(bool enabled) +{ + m_private->setBoolean(WebKitJavaScriptEnabled, enabled); +} + +bool WebSettings::isPrivateBrowsingEnabled() const +{ + return m_private->getBoolean(WebKitPrivateBrowsingEnabled); +} + +void WebSettings::setPrivateBrowsingEnabled(bool enabled) +{ + m_private->setBoolean(WebKitPrivateBrowsingEnabled, enabled); +} + +int WebSettings::defaultFixedFontSize() const +{ + return m_private->getInteger(WebKitDefaultFixedFontSize); +} + +void WebSettings::setDefaultFixedFontSize(int defaultFixedFontSize) +{ + m_private->setInteger(WebKitDefaultFixedFontSize, defaultFixedFontSize); +} + +int WebSettings::defaultFontSize() const +{ + return m_private->getInteger(WebKitDefaultFontSize); +} + +void WebSettings::setDefaultFontSize(int defaultFontSize) +{ + m_private->setInteger(WebKitDefaultFontSize, defaultFontSize); +} + +int WebSettings::minimumFontSize() const +{ + return m_private->getInteger(WebKitMinimumFontSize); +} + +void WebSettings::setMinimumFontSize(int minimumFontSize) +{ + m_private->setInteger(WebKitMinimumFontSize, minimumFontSize); +} + +WebString WebSettings::serifFontFamily() const +{ + return m_private->getString(WebKitSeriffFontFamily); +} + +void WebSettings::setSerifFontFamily(const char* seriffFontFamily) +{ + m_private->setString(WebKitSeriffFontFamily, seriffFontFamily); +} + +WebString WebSettings::fixedFontFamily() const +{ + return m_private->getString(WebKitFixedFontFamily); +} + +void WebSettings::setFixedFontFamily(const char* fixedFontFamily) +{ + m_private->setString(WebKitFixedFontFamily, fixedFontFamily); +} + +WebString WebSettings::sansSerifFontFamily() const +{ + return m_private->getString(WebKitSansSeriffFontFamily); +} + +void WebSettings::setSansSerifFontFamily(const char* sansSeriffFontFamily) +{ + m_private->setString(WebKitSansSeriffFontFamily, sansSeriffFontFamily); +} + +WebString WebSettings::standardFontFamily() const +{ + return m_private->getString(WebKitStandardFontFamily); +} + +void WebSettings::setStandardFontFamily(const char* standardFontFamily) +{ + m_private->setString(WebKitStandardFontFamily, standardFontFamily); +} + +WebString WebSettings::userAgentString() const +{ + // FIXME: Is this the best place for this assertion. Why can't we just return an empty string + // and let the caller decide how to handle it? + + // The default user agent string is empty. We rely upon the client to set this for us. + // We check this by asserting if the client has not done so before the first time it is needed. + String userAgentString = m_private->getString(BlackBerryUserAgentString); + ASSERT(!userAgentString.isEmpty()); + return userAgentString; +} + +void WebSettings::setUserAgentString(const char* userAgentString) +{ + m_private->setString(BlackBerryUserAgentString, userAgentString); +} + +WebString WebSettings::defaultTextEncodingName() const +{ + return m_private->getString(WebKitDefaultTextEncodingName); +} + +void WebSettings::setDefaultTextEncodingName(const char* defaultTextEncodingName) +{ + m_private->setString(WebKitDefaultTextEncodingName, defaultTextEncodingName); +} + +bool WebSettings::isZoomToFitOnLoad() const +{ + return m_private->getBoolean(BlackBerryZoomToFitOnLoadEnabled); +} + +void WebSettings::setZoomToFitOnLoad(bool enabled) +{ + m_private->setBoolean(BlackBerryZoomToFitOnLoadEnabled, enabled); +} + +WebSettings::TextReflowMode WebSettings::textReflowMode() const +{ + return m_private->getTextReflowMode(BlackBerryTextReflowMode); +} + +void WebSettings::setTextReflowMode(TextReflowMode textReflowMode) +{ + m_private->setTextReflowMode(BlackBerryTextReflowMode, textReflowMode); +} + +bool WebSettings::isScrollbarsEnabled() const +{ + return m_private->getBoolean(BlackBerryScrollbarsEnabled); +} + +void WebSettings::setScrollbarsEnabled(bool enabled) +{ + m_private->setBoolean(BlackBerryScrollbarsEnabled, enabled); +} + +bool WebSettings::canJavaScriptOpenWindowsAutomatically() const +{ + return m_private->getBoolean(WebKitJavaScriptCanOpenWindowsAutomaticallyEnabled); +} + +void WebSettings::setJavaScriptOpenWindowsAutomatically(bool enabled) +{ + m_private->setBoolean(WebKitJavaScriptCanOpenWindowsAutomaticallyEnabled, enabled); +} + +bool WebSettings::arePluginsEnabled() const +{ + return m_private->getBoolean(WebKitPluginsEnabled); +} + +void WebSettings::setPluginsEnabled(bool enabled) +{ + m_private->setBoolean(WebKitPluginsEnabled, enabled); +} + +bool WebSettings::isGeolocationEnabled() const +{ + return m_private->getBoolean(WebKitGeolocationEnabled); +} + +void WebSettings::setGeolocationEnabled(bool enabled) +{ + m_private->setBoolean(WebKitGeolocationEnabled, enabled); +} + +bool WebSettings::doesGetFocusNodeContext() const +{ + return m_private->getBoolean(BlackBerryGetFocusNodeContextEnabled); +} + +void WebSettings::setGetFocusNodeContext(bool enabled) +{ + m_private->setBoolean(BlackBerryGetFocusNodeContextEnabled, enabled); +} + +WebString WebSettings::userStyleSheetString() const +{ + return m_private->getString(WebKitUserStyleSheet); +} + +void WebSettings::setUserStyleSheetString(const char* userStyleSheetString) +{ + // FIXME: This doesn't seem like the appropriate place to do this as WebSettings should ideally be a state store. + // Either the caller of this function should do this conversion or caller of the getter corresponding to this function + // should do this conversion. + + size_t length = strlen(userStyleSheetString); + Vector<char> data; + data.append(userStyleSheetString, length); + + Vector<char> encodedData; + WebCore::base64Encode(data, encodedData); + + const char prefix[] = "data:text/css;charset=utf-8;base64,"; + size_t prefixLength = sizeof(prefix) - 1; + Vector<char> dataURL; + dataURL.reserveCapacity(prefixLength + encodedData.size()); + dataURL.append(prefix, prefixLength); + dataURL.append(encodedData); + m_private->setString(WebKitUserStyleSheet, String(dataURL.data(), dataURL.size())); +} + +WebString WebSettings::userStyleSheetLocation() +{ + return m_private->getString(WebKitUserStyleSheetLocation); +} + +void WebSettings::setUserStyleSheetLocation(const char* userStyleSheetLocation) +{ + m_private->setString(WebKitUserStyleSheetLocation, userStyleSheetLocation); +} + +bool WebSettings::areLinksHandledExternally() const +{ + return m_private->getBoolean(BlackBerryLinksHandledExternallyEnabled); +} + +void WebSettings::setAreLinksHandledExternally(bool enabled) +{ + m_private->setBoolean(BlackBerryLinksHandledExternallyEnabled, enabled); +} + +void WebSettings::setAllowCrossSiteRequests(bool allow) +{ + m_private->setBoolean(BlackBerryAllowCrossSiteRequests, allow); +} + +bool WebSettings::allowCrossSiteRequests() const +{ + return m_private->getBoolean(BlackBerryAllowCrossSiteRequests); +} + +bool WebSettings::isUserScalable() const +{ + return m_private->getBoolean(BlackBerryUserScalableEnabled); +} + +void WebSettings::setUserScalable(bool enabled) +{ + m_private->setBoolean(BlackBerryUserScalableEnabled, enabled); +} + +int WebSettings::viewportWidth() const +{ + return m_private->getInteger(BlackBerryViewportWidth); +} + +void WebSettings::setViewportWidth(int width) +{ + m_private->setInteger(BlackBerryViewportWidth, width); +} + +double WebSettings::initialScale() const +{ + return m_private->getDouble(BlackBerryInitialScale); +} + +void WebSettings::setInitialScale(double initialScale) +{ + m_private->setDouble(BlackBerryInitialScale, initialScale); +} + +int WebSettings::firstScheduledLayoutDelay() const +{ + return m_private->getInteger(WebKitFirstScheduledLayoutDelay); +} + +void WebSettings::setFirstScheduledLayoutDelay(int delay) +{ + m_private->setInteger(WebKitFirstScheduledLayoutDelay, delay); +} + +// Whether to include pattern: in the list of string patterns. +bool WebSettings::shouldHandlePatternUrls() const +{ + return m_private->getBoolean(BlackBerryHandlePatternURLs); +} + +void WebSettings::setShouldHandlePatternUrls(bool handlePatternURLs) +{ + m_private->setBoolean(BlackBerryHandlePatternURLs, handlePatternURLs); +} + +bool WebSettings::areCookiesEnabled() const +{ + return m_private->getBoolean(BlackBerryCookiesEnabled); +} + +void WebSettings::setAreCookiesEnabled(bool enable) +{ + m_private->setBoolean(BlackBerryCookiesEnabled, enable); +} + +bool WebSettings::isLocalStorageEnabled() const +{ + return m_private->getBoolean(WebKitLocalStorageEnabled); +} + +void WebSettings::setIsLocalStorageEnabled(bool enable) +{ + m_private->setBoolean(WebKitLocalStorageEnabled, enable); +} + +bool WebSettings::isDatabasesEnabled() const +{ + return m_private->getBoolean(WebKitDatabasesEnabled); +} + +void WebSettings::setIsDatabasesEnabled(bool enable) +{ + m_private->setBoolean(WebKitDatabasesEnabled, enable); +} + +bool WebSettings::isAppCacheEnabled() const +{ + return m_private->getBoolean(WebKitOfflineWebApplicationCacheEnabled); +} + +void WebSettings::setIsAppCacheEnabled(bool enable) +{ + m_private->setBoolean(WebKitOfflineWebApplicationCacheEnabled, enable); +} + +unsigned long long WebSettings::localStorageQuota() const +{ + return m_private->getUnsignedLongLong(WebKitLocalStorageQuota); +} + +void WebSettings::setLocalStorageQuota(unsigned long long quota) +{ + m_private->setUnsignedLongLong(WebKitLocalStorageQuota, quota); +} + +int WebSettings::maximumPagesInCache() const +{ + // FIXME: We shouldn't be calling into WebCore from here. This class should just be a state store. + return WebCore::pageCache()->capacity(); +} + +void WebSettings::setMaximumPagesInCache(int pages) +{ + // FIXME: We shouldn't be calling into WebCore from here. This class should just be a state store. + unsigned realPages = std::max(0, pages); + WebCore::pageCache()->setCapacity(realPages); + m_private->setUnsigned(WebKitMaximumPagesInCache, realPages); +} + +WebString WebSettings::localStoragePath() const +{ + return m_private->getString(WebKitLocalStoragePath); +} + +void WebSettings::setLocalStoragePath(const WebString& path) +{ + m_private->setString(WebKitLocalStoragePath, path); +} + +WebString WebSettings::databasePath() const +{ + return m_private->getString(WebKitDatabasePath); +} + +void WebSettings::setDatabasePath(const WebString& path) +{ + m_private->setString(WebKitDatabasePath, path); +} + +WebString WebSettings::appCachePath() const +{ + return m_private->getString(WebKitOfflineWebApplicationCachePath); +} + +void WebSettings::setAppCachePath(const WebString& path) +{ + m_private->setString(WebKitOfflineWebApplicationCachePath, path); +} + +WebString WebSettings::pageGroupName() const +{ + return m_private->getString(WebKitPageGroupName); +} + +void WebSettings::setPageGroupName(const WebString& pageGroupName) +{ + m_private->setString(WebKitPageGroupName, pageGroupName); +} + +bool WebSettings::isEmailMode() const +{ + return m_private->getBoolean(BlackBerryEmailModeEnabled); +} + +void WebSettings::setEmailMode(bool enable) +{ + m_private->setBoolean(BlackBerryEmailModeEnabled, enable); +} + +bool WebSettings::shouldRenderAnimationsOnScrollOrZoom() const +{ + return m_private->getBoolean(BlackBerryRenderAnimationsOnScrollOrZoomEnabled); +} + +void WebSettings::setShouldRenderAnimationsOnScrollOrZoom(bool enable) +{ + m_private->setBoolean(BlackBerryRenderAnimationsOnScrollOrZoomEnabled, enable); +} + +unsigned WebSettings::overZoomColor() const +{ + return m_private->getUnsigned(BlackBerryOverZoomColor); +} + +void WebSettings::setOverZoomColor(unsigned color) +{ + m_private->setUnsigned(BlackBerryOverZoomColor, color); +} + +unsigned WebSettings::backgroundColor() const +{ + return m_private->getUnsigned(BlackBerryBackgroundColor); +} + +void WebSettings::setBackgroundColor(unsigned color) +{ + m_private->setUnsigned(BlackBerryBackgroundColor, color); +} + +bool WebSettings::isWritingDirectionRTL() const +{ + return m_private->getBoolean(BlackBerryUseRTLWritingDirection); +} + +void WebSettings::setWritingDirectionRTL(bool useRTLWritingDirection) +{ + m_private->setBoolean(BlackBerryUseRTLWritingDirection, useRTLWritingDirection); +} + +bool WebSettings::useWebKitCache() const +{ + return m_private->getBoolean(BlackBerryUseWebKitCache); +} + +void WebSettings::setUseWebKitCache(bool useWebKitCache) +{ + m_private->setBoolean(BlackBerryUseWebKitCache, useWebKitCache); +} + +bool WebSettings::isFrameFlatteningEnabled() const +{ + return m_private->getBoolean(WebKitFrameFlatteningEnabled); +} + +void WebSettings::setFrameFlatteningEnabled(bool enable) +{ + m_private->setBoolean(WebKitFrameFlatteningEnabled, enable); +} + +bool WebSettings::isDirectRenderingToWindowEnabled() const +{ + return m_private->getBoolean(BlackBerryDirectRenderingToWindowEnabled); +} + +void WebSettings::setDirectRenderingToWindowEnabled(bool enable) +{ + m_private->setBoolean(BlackBerryDirectRenderingToWindowEnabled, enable); +} + +unsigned WebSettings::maxPluginInstances() const +{ + return m_private->getUnsigned(BlackBerryMaxPluginInstances); +} + +void WebSettings::setMaxPluginInstances(unsigned maxPluginInstances) +{ + m_private->setUnsigned(BlackBerryMaxPluginInstances, maxPluginInstances); +} + +bool WebSettings::areWebSocketsEnabled() const +{ + return m_private->getBoolean(WebKitWebSocketsEnabled); +} + +void WebSettings::setWebSocketsEnabled(bool enable) +{ + m_private->setBoolean(WebKitWebSocketsEnabled, enable); +} + +bool WebSettings::isSpatialNavigationEnabled() const +{ + return m_private->getBoolean(SpatialNavigationEnabled); +} + +void WebSettings::setSpatialNavigationEnabled(bool enable) +{ + m_private->setBoolean(SpatialNavigationEnabled, enable); +} + +} // namespace WebKit +} // namespace BlackBerry diff --git a/Source/WebKit/blackberry/Api/WebSettings.h b/Source/WebKit/blackberry/Api/WebSettings.h new file mode 100644 index 000000000..403e8f4a2 --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebSettings.h @@ -0,0 +1,263 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebSettings_h +#define WebSettings_h + +#include "BlackBerryGlobal.h" + +namespace BlackBerry { +namespace WebKit { + +class WebSettings; +class WebSettingsPrivate; + +/*! + @struct WebSettingsDelegate + Defines the methods that must be implemented by a delegate of WebSettings. +*/ +struct BLACKBERRY_EXPORT WebSettingsDelegate { + virtual ~WebSettingsDelegate() { } + + /*! + Sent when the value of a setting changed as well as on instantiation of a WebSettings object. + @param settings The WebSettings object that sent the message. + */ + virtual void didChangeSettings(WebSettings*) = 0; +}; + +/*! + @class WebSettings +*/ +class BLACKBERRY_EXPORT WebSettings { +public: + static WebSettings* createFromStandardSettings(WebSettingsDelegate* = 0); + ~WebSettings(); + + static WebSettings* standardSettings(); + + void setDelegate(WebSettingsDelegate*); + WebSettingsDelegate* delegate(); + + static void addSupportedObjectPluginMIMEType(const char*); + static bool isSupportedObjectMIMEType(const WebString&); + static WebString getNormalizedMIMEType(const WebString&); + + bool xssAuditorEnabled() const; + void setXSSAuditorEnabled(bool); + + bool loadsImagesAutomatically() const; + void setLoadsImagesAutomatically(bool); + + bool shouldDrawBorderWhileLoadingImages() const; + void setShouldDrawBorderWhileLoadingImages(bool); + + bool isJavaScriptEnabled() const; + void setJavaScriptEnabled(bool); + + bool isPrivateBrowsingEnabled() const; + void setPrivateBrowsingEnabled(bool); + + int defaultFixedFontSize() const; + void setDefaultFixedFontSize(int); + + int defaultFontSize() const; + void setDefaultFontSize(int); + + int minimumFontSize() const; + void setMinimumFontSize(int); + + WebString serifFontFamily() const; + void setSerifFontFamily(const char*); + WebString fixedFontFamily() const; + void setFixedFontFamily(const char*); + WebString sansSerifFontFamily() const; + void setSansSerifFontFamily(const char*); + WebString standardFontFamily() const; + void setStandardFontFamily(const char*); + + void setDownloadableBinaryFontsEnabled(bool); + bool downloadableBinaryFontsEnabled() const; + + WebString userAgentString() const; + void setUserAgentString(const char*); + + WebString defaultTextEncodingName() const; + void setDefaultTextEncodingName(const char*); + + bool isZoomToFitOnLoad() const; + void setZoomToFitOnLoad(bool); + + enum TextReflowMode { TextReflowDisabled, TextReflowEnabled, TextReflowEnabledOnlyForBlockZoom }; + TextReflowMode textReflowMode() const; + void setTextReflowMode(TextReflowMode); + + bool isScrollbarsEnabled() const; + void setScrollbarsEnabled(bool); + + // FIXME: Consider renaming this method upstream, where it is called javaScriptCanOpenWindowsAutomatically. + bool canJavaScriptOpenWindowsAutomatically() const; + void setJavaScriptOpenWindowsAutomatically(bool); + + bool arePluginsEnabled() const; + void setPluginsEnabled(bool); + + bool isGeolocationEnabled() const; + void setGeolocationEnabled(bool); + + // Context info + bool doesGetFocusNodeContext() const; + void setGetFocusNodeContext(bool); + + WebString userStyleSheetString() const; + void setUserStyleSheetString(const char*); + + WebString userStyleSheetLocation(); + void setUserStyleSheetLocation(const char*); + + // External link handlers + bool areLinksHandledExternally() const; + void setAreLinksHandledExternally(bool); + + // BrowserField2 settings + void setAllowCrossSiteRequests(bool); + bool allowCrossSiteRequests() const; + bool isUserScalable() const; + void setUserScalable(bool); + int viewportWidth() const; + void setViewportWidth(int); + double initialScale() const; + void setInitialScale(double); + + int firstScheduledLayoutDelay() const; + void setFirstScheduledLayoutDelay(int); + + // Whether to include pattern: in the list of string patterns. + bool shouldHandlePatternUrls() const; + void setShouldHandlePatternUrls(bool); + + bool areCookiesEnabled() const; + void setAreCookiesEnabled(bool); + + // Web storage settings + bool isLocalStorageEnabled() const; + void setIsLocalStorageEnabled(bool); + + bool isDatabasesEnabled() const; + void setIsDatabasesEnabled(bool); + + bool isAppCacheEnabled() const; + void setIsAppCacheEnabled(bool); + + unsigned long long localStorageQuota() const; + void setLocalStorageQuota(unsigned long long); + + // Page cache + void setMaximumPagesInCache(int); + int maximumPagesInCache() const; + + WebString localStoragePath() const; + void setLocalStoragePath(const WebString&); + + WebString databasePath() const; + void setDatabasePath(const WebString&); + + WebString appCachePath() const; + void setAppCachePath(const WebString&); + + WebString pageGroupName() const; + void setPageGroupName(const WebString&); + + // FIXME: We shouldn't have an email mode. Instead, we should expose all email-related settings + // so that the email client can toggle them directly. + bool isEmailMode() const; + void setEmailMode(bool enable); + + bool shouldRenderAnimationsOnScrollOrZoom() const; + void setShouldRenderAnimationsOnScrollOrZoom(bool enable); + + unsigned overZoomColor() const; + void setOverZoomColor(unsigned); + + unsigned backgroundColor() const; + void setBackgroundColor(unsigned); + + bool isWritingDirectionRTL() const; + void setWritingDirectionRTL(bool); + + bool useWebKitCache() const; + void setUseWebKitCache(bool); + + bool isFrameFlatteningEnabled() const; + void setFrameFlatteningEnabled(bool); + + bool isDirectRenderingToWindowEnabled() const; + void setDirectRenderingToWindowEnabled(bool); + + unsigned maxPluginInstances() const; + void setMaxPluginInstances(unsigned num); + + bool areWebSocketsEnabled() const; + void setWebSocketsEnabled(bool); + + bool isSpatialNavigationEnabled() const; + void setSpatialNavigationEnabled(bool); + +private: + WebSettingsPrivate* m_private; + WebSettings(); + WebSettings(const WebSettings&); +}; + +/*! + @class WebSettingsTransaction + Defines a scope guard that suppresses didChangeSettings messages within its scope. + On destruction the guarded WebSettings object will dispatch exactly one didChangeSettings message. +*/ +class BLACKBERRY_EXPORT WebSettingsTransaction { +public: + WebSettingsTransaction(WebSettings* settings) + : m_settings(settings) + , m_savedDelegate(0) + { + if (!settings) + return; + m_savedDelegate = settings->delegate(); + settings->setDelegate(0); + } + + ~WebSettingsTransaction() + { + if (!m_settings || !m_savedDelegate) + return; + m_settings->setDelegate(m_savedDelegate); + m_savedDelegate->didChangeSettings(m_settings); + } + +private: + WebSettingsTransaction(const WebSettingsTransaction&); + WebSettingsTransaction& operator=(const WebSettingsTransaction&); + + WebSettings* m_settings; + WebSettingsDelegate* m_savedDelegate; +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // WebSettings_h diff --git a/Source/WebKit/blackberry/Api/WebSettings_p.h b/Source/WebKit/blackberry/Api/WebSettings_p.h new file mode 100644 index 000000000..7f9e2334d --- /dev/null +++ b/Source/WebKit/blackberry/Api/WebSettings_p.h @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebSettings_p_h +#define WebSettings_p_h + +#include "WebSettings.h" + +#include <wtf/HashMap.h> +#include <wtf/text/StringHash.h> + +#define synthesizeAccessorsForPrimitiveValuePrefixAndType(prefix, type) \ + void set##prefix(const String& key, type newValue) { \ + ASSERT(impl); \ + if (get##prefix(key) == newValue) \ + return; \ + if (copyOnWrite) { \ + copyOnWrite = false; \ + impl = new WebSettingsPrivateImpl(*impl); \ + } \ + PrimitiveValue primitiveValue; \ + primitiveValue.prefix##Value = newValue; \ + impl->primitiveValues.set(key, primitiveValue); \ + if (delegate) \ + delegate->didChangeSettings(sender); \ + } \ + type get##prefix(const String& key) const { \ + ASSERT(impl); \ + if (!impl->primitiveValues.contains(key)) \ + return static_cast<type>(false); \ + return impl->primitiveValues.get(key).prefix##Value; \ + } + +namespace BlackBerry { +namespace WebKit { + +struct WebSettingsPrivate { + union PrimitiveValue { + WebSettings::TextReflowMode TextReflowModeValue; + bool BooleanValue; + double DoubleValue; + int IntegerValue; + unsigned UnsignedValue; + unsigned long long UnsignedLongLongValue; + }; + + struct WebSettingsPrivateImpl { + HashMap<String, PrimitiveValue> primitiveValues; + HashMap<String, String> stringValues; + }; + + WebSettingsPrivateImpl* impl; + WebSettingsDelegate* delegate; + WebSettings* sender; + bool copyOnWrite; + + WebSettingsPrivate(); + + synthesizeAccessorsForPrimitiveValuePrefixAndType(TextReflowMode, WebSettings::TextReflowMode); + + synthesizeAccessorsForPrimitiveValuePrefixAndType(Boolean, bool); + + synthesizeAccessorsForPrimitiveValuePrefixAndType(Double, double); + + synthesizeAccessorsForPrimitiveValuePrefixAndType(Integer, int); + + synthesizeAccessorsForPrimitiveValuePrefixAndType(Unsigned, unsigned); + + synthesizeAccessorsForPrimitiveValuePrefixAndType(UnsignedLongLong, unsigned long long); + + String getString(const String& key) const + { + ASSERT(impl); + if (!impl->stringValues.contains(key)) + return String(); + return impl->stringValues.get(key); + } + + void setString(const String& key, const String& newValue) + { + ASSERT(impl); + if (getString(key) == newValue) + return; + + if (copyOnWrite) { + copyOnWrite = false; + impl = new WebSettingsPrivateImpl(*impl); + } + + impl->stringValues.set(key, newValue); + if (delegate) + delegate->didChangeSettings(sender); + } +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // WebSettings_p_h diff --git a/Source/WebKit/blackberry/Api/WebString.cpp b/Source/WebKit/blackberry/Api/WebString.cpp index 7429d86de..7fc9a1a77 100644 --- a/Source/WebKit/blackberry/Api/WebString.cpp +++ b/Source/WebKit/blackberry/Api/WebString.cpp @@ -19,7 +19,6 @@ #include "config.h" #include "WebString.h" -#include "WebStringImpl.h" #include <wtf/text/CString.h> #include <wtf/text/WTFString.h> @@ -27,21 +26,21 @@ namespace BlackBerry { namespace WebKit { WebString::WebString(const char* latin1) - : m_impl(static_cast<WebStringImpl*>(WTF::StringImpl::create(latin1).releaseRef())) + : m_impl(StringImpl::create(latin1).leakRef()) { } WebString::WebString(const char* latin1, unsigned length) - : m_impl(static_cast<WebStringImpl*>(WTF::StringImpl::create(latin1, length).releaseRef())) + : m_impl(StringImpl::create(latin1, length).leakRef()) { } WebString::WebString(const unsigned short* utf16, unsigned length) - : m_impl(static_cast<WebStringImpl*>(WTF::StringImpl::create(utf16, length).releaseRef())) + : m_impl(StringImpl::create(utf16, length).leakRef()) { } -WebString::WebString(WebStringImpl* impl) +WebString::WebString(StringImpl* impl) : m_impl(impl) { if (m_impl) @@ -109,7 +108,7 @@ bool WebString::equal(const char* utf8) const bool WebString::equalIgnoringCase(const char* utf8) const { - return WTF::equalIgnoringCase(m_impl, utf8); + return WTF::equalIgnoringCase(utf8, WTF::String(m_impl)); } } // namespace WebKit diff --git a/Source/WebKit/blackberry/Api/WebString.h b/Source/WebKit/blackberry/Api/WebString.h index fe28bdef6..fe43c247f 100644 --- a/Source/WebKit/blackberry/Api/WebString.h +++ b/Source/WebKit/blackberry/Api/WebString.h @@ -22,11 +22,14 @@ #include "BlackBerryGlobal.h" #include <string> +// Not for public API purpose. +namespace WTF { +class StringImpl; +} + namespace BlackBerry { namespace WebKit { -class WebStringImpl; - class BLACKBERRY_EXPORT WebString { public: WebString() : m_impl(0) { } @@ -34,7 +37,6 @@ public: WebString(const char* latin1); WebString(const char* latin1, unsigned length); WebString(const unsigned short* utf16, unsigned length); - WebString(WebStringImpl*); WebString(const WebString&); WebString& operator=(const WebString&); std::string utf8() const; @@ -44,9 +46,13 @@ public: bool isEmpty() const; bool equal(const char* utf8) const; bool equalIgnoringCase(const char* utf8) const; - WebStringImpl* impl() const { return m_impl; } + + // Not for public API purpose. + WebString(WTF::StringImpl*); + WTF::StringImpl* impl() const { return m_impl; } + private: - WebStringImpl* m_impl; + WTF::StringImpl* m_impl; }; } // namespace WebKit } // namespace BlackBerry diff --git a/Source/WebKit/blackberry/ChangeLog b/Source/WebKit/blackberry/ChangeLog new file mode 100644 index 000000000..60d341ad0 --- /dev/null +++ b/Source/WebKit/blackberry/ChangeLog @@ -0,0 +1,390 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/EditorClientBlackBerry.cpp: + (WebCore::EditorClientBlackBerry::requestCheckingOfString): + * WebCoreSupport/EditorClientBlackBerry.h: + (EditorClientBlackBerry): + +2012-02-24 Charles Wei <charles.wei@torchmobile.com.cn> + + [BlackBerry] Anchor mailto: with target set won't launch Messaging application when clicked + https://bugs.webkit.org/show_bug.cgi?id=79318 + + Need to give the client a chance to decide how to handle the new window request. + + Reviewed by Rob Buis. + + * WebCoreSupport/FrameLoaderClientBlackBerry.cpp: + (WebCore::FrameLoaderClientBlackBerry::dispatchDecidePolicyForNewWindowAction): + +2012-02-23 Mike Fenton <mifenton@rim.com> + + [BlackBerry] Selection handler has compile failure with logs enabled. + https://bugs.webkit.org/show_bug.cgi?id=79392 + + Reviewed by Antonio Gomes. + + Build Fix. Update log to avoid usage of toString which was removed. + + * WebKitSupport/SelectionHandler.cpp: + (BlackBerry::WebKit::SelectionHandler::selectionPositionChanged): + +2012-02-19 Antonio Gomes <agomes@rim.com> + + Fat fingers - Add a clearer way to distinguish the node we want (shadow or non-shadow) + https://bugs.webkit.org/show_bug.cgi?id=79256 + PR #127814 / MKS_2587410 + + Reviewed by Rob Buis. + + Patch adds a cleaner way for call sites of FatFingersResult to + query for the appropriated target node: shadow or non-shadow DOM nodes. + + It also renames FatFingersResults::validNode to ::node, assuming + that "invalid" nodes are not applicable in any context. + + * Api/WebPage.cpp: + (BlackBerry::WebKit::WebPagePrivate::clearDocumentData): + (BlackBerry::WebKit::WebPagePrivate::contextNode): + (BlackBerry::WebKit::WebPagePrivate::handleMouseEvent): + * WebKitSupport/FatFingers.h: + (FatFingersResult): + (BlackBerry::WebKit::FatFingersResult::node): + (BlackBerry::WebKit::FatFingersResult::nodeAsElementIfApplicable): + * WebKitSupport/SelectionHandler.cpp: + (BlackBerry::WebKit::SelectionHandler::selectAtPoint): + * WebKitSupport/TouchEventHandler.cpp: + (BlackBerry::WebKit::TouchEventHandler::touchHoldEvent): + (BlackBerry::WebKit::TouchEventHandler::handleTouchPoint): + +2012-02-23 Jacky Jiang <zhajiang@rim.com> + + [BlackBerry] Upstream BlackBerry API web page related files + https://bugs.webkit.org/show_bug.cgi?id=74380 + + Reviewed by Antonio Gomes. + + Initial upstream, no new tests. + + * Api/WebPage.cpp: Added. + * Api/WebPage.h: Added. + * Api/WebPage_p.h: Added. + +2012-02-23 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Remove unused ChromeClientBlackBerry::platformCompositingWindow(), platformWindow() and WebPageClient::compositingWindow() + https://bugs.webkit.org/show_bug.cgi?id=78681 + + Reviewed by Antonio Gomes. + + * Api/WebPageClient.h: + * WebCoreSupport/ChromeClientBlackBerry.cpp: + (WebCore): + * WebCoreSupport/ChromeClientBlackBerry.h: + (ChromeClientBlackBerry): + +2012-02-23 Leo Yang <leo.yang@torchmobile.com.cn> + + [BlackBerry] Upstream GLES2Context.{h, cpp} + https://bugs.webkit.org/show_bug.cgi?id=79196 + + Reviewed by Rob Buis. + + Initial upstream, no new tests. + + * WebKitSupport/GLES2Context.cpp: Added. + * WebKitSupport/GLES2Context.h: Added. + +2012-02-23 Mike Fenton <mifenton@rim.com> + + [BlackBerry] InputHandler requires cleanup of Navigation Mode handling. + https://bugs.webkit.org/show_bug.cgi?id=79366 + + Reviewed by Rob Buis. + + Cleanup InputHandler navigation based code. + + 1) Remove the concept of NavigationMode and replace it + with simple showKeyboard calls. + + 2) Remove navigation move events and replace with standard + key events. + + 3) Standardize function/variable names and remove obsolete + functions. + + * Api/WebPageClient.h: + * WebKitSupport/InputHandler.cpp: + (BlackBerry::WebKit::InputHandler::InputHandler): + (BlackBerry::WebKit::InputHandler::nodeFocused): + (BlackBerry::WebKit::InputHandler::setElementUnfocused): + (BlackBerry::WebKit::InputHandler::setElementFocused): + (BlackBerry::WebKit::InputHandler::ensureFocusTextElementVisible): + (BlackBerry::WebKit::InputHandler::setDelayKeyboardVisibilityChange): + (BlackBerry::WebKit::InputHandler::processPendingKeyboardVisibilityChange): + (BlackBerry::WebKit::InputHandler::notifyClientOfKeyboardVisibilityChange): + * WebKitSupport/InputHandler.h: + (InputHandler): + * WebKitSupport/SelectionHandler.cpp: + (BlackBerry::WebKit::SelectionHandler::setCaretPosition): + (BlackBerry::WebKit::SelectionHandler::updateOrHandleInputSelection): + * WebKitSupport/TouchEventHandler.cpp: + (BlackBerry::WebKit::TouchEventHandler::touchEventCancel): + (BlackBerry::WebKit::TouchEventHandler::handleTouchPoint): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientBlackBerry.cpp: + (WebCore::EditorClientBlackBerry::shouldApplyStyle): + * WebCoreSupport/EditorClientBlackBerry.h: + (EditorClientBlackBerry): + +2012-02-22 Mike Fenton <mifenton@rim.com> + + [BlackBerry] InputHandler has signed vs unsigned comparison. + https://bugs.webkit.org/show_bug.cgi?id=79261 + + Fix warning by casting the unsigned int to an int. + + Reviewed by Rob Buis. + + * WebKitSupport/InputHandler.cpp: + (BlackBerry::WebKit::InputHandler::rectForCaret): + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientBlackBerry.cpp: + (WebCore::EditorClientBlackBerry::shouldApplyStyle): + * WebCoreSupport/EditorClientBlackBerry.h: + (EditorClientBlackBerry): + +2012-02-18 Antonio Gomes <agomes@rim.com> + + Fat fingers - cache the first rect-based hit test so we do not need to do it again + https://bugs.webkit.org/show_bug.cgi?id=79115 + + Reviewed by Adam Treat. + + Our FatFingers implementation runs currently in two phases: + the first checks for the elements intrinsically clickable; + the second checks for elements made clickable by the page + (for example, a div with a onclick event listener attached to it). + For each phase, we perform a rect hittest, which is not needed since + the result of each is the same. + + Patch introduces a caching mechanism so we avoid on rect hittest: + when the first phase runs, it caches each nodeset per document in + a hashmap. This second phase works with the cached results. + + No behavioral change, but performance is better since we + avoid one (possibly expensive) rect hittest. + + I measured the performance gain on https://www.kvd.se/, and we + save up to 0.04 seconds, by caching and re-using the results. + + * WebKitSupport/FatFingers.cpp: + (BlackBerry::WebKit::dumpHitTestResult): + (BlackBerry::WebKit::FatFingers::findBestPoint): + (BlackBerry::WebKit::FatFingers::findIntersectingRegions): + (BlackBerry::WebKit::FatFingers::cachingStrategy): + (WebKit): + (BlackBerry::WebKit::FatFingers::getNodesFromRect): + * WebKitSupport/FatFingers.h: + +2012-02-20 Antonio Gomes <agomes@rim.com> + + All default video/audio control elements should be rect-hit testable (Part II) + PR #139518 / MKS_3005538 + + Reviewed by George Staikos. + + Add HTMLInputElement::isMediaControlElement as a criteria + to consider a element as clickable. + + Note that is should be only used while in the "ClickableByDefault" + phase of FatFingers. + + * WebKitSupport/FatFingers.cpp: + (BlackBerry::WebKit::FatFingers::isElementClickable): + +2012-02-16 Antonio Gomes <agomes@rim.com> + + [BlackBerry] Implemented a way to defer client navigation change client notifications + https://bugs.webkit.org/show_bug.cgi?id=78848 + + Reviewed by Rob Buis. + + Currently we postpone touch_down till touch_up if user touches + the screen and an input field has the WebKit focus. This is done + so we can scroll the page without hidding the vkb needlessly. + + However, it breaks the conversion of touch to mouse events + if an input field has the focus in the following scenario: + an <input type=text> is focused and an user grab and-drag + a <input type=range> knob/slide. It does not work until the + user unfocuses the currently focused edit field. + + Patch introduces a way to unfocus a currently focused input field, + without requesting the client to show or hide the virtual keyboard + right way. Instead it gets a delayed notification of the vkb mode requested + at either touch_released/mouse_up or touch_cancel time. + + For now, due to content side issues with major web sites, + only delay navigation mode notification changes if we are not dealing with + input modes. + + * WebKitSupport/InputHandler.cpp: + (BlackBerry::WebKit::InputHandler::InputHandler): + (BlackBerry::WebKit::InputHandler::nodeFocused): + (BlackBerry::WebKit::InputHandler::setElementFocused): + (BlackBerry::WebKit::InputHandler::setNavigationMode): + (WebKit): + (BlackBerry::WebKit::InputHandler::setDelayClientNotificationOfNavigationModeChange): + (BlackBerry::WebKit::InputHandler::processPendingClientNavigationModeChangeNotification): + (BlackBerry::WebKit::InputHandler::notifyClientOfNavigationModeChange): + (BlackBerry::WebKit::InputHandler::willOpenPopupForNode): + (BlackBerry::WebKit::InputHandler::setPopupListIndexes): + (BlackBerry::WebKit::InputHandler::spannableTextInRange): + (BlackBerry::WebKit::InputHandler::removeComposedText): + (BlackBerry::WebKit::InputHandler::firstSpanInString): + (BlackBerry::WebKit::InputHandler::setText): + (BlackBerry::WebKit::InputHandler::setRelativeCursorPosition): + * WebKitSupport/InputHandler.h: + (InputHandler): + +2012-02-16 Antonio Gomes <agomes@rim.com> + + Crash @WebPagePrivate::enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling MKS_2986818 + https://bugs.webkit.org/show_bug.cgi?id=78845 + + Reviewed by Rob Buis. + + We were trying to operate on a cached Node when its page/frame/document + were gone to PageCache already. To avoid such problems, lets clean up + any document data we have cached when the Frame goes into the cache. + + * WebCoreSupport/FrameLoaderClientBlackBerry.cpp: + (WebCore::FrameLoaderClientBlackBerry::didSaveToPageCache): + (WebCore): + * WebCoreSupport/FrameLoaderClientBlackBerry.h: + (FrameLoaderClientBlackBerry): + +2012-02-16 Antonio Gomes <agomes@rim.com> + + [BlackBerry] Upstream touch handling related classes + https://bugs.webkit.org/show_bug.cgi?id=78509 + + Reviewed by Adam Treat and Rob Buis. + + FatFingers is the class responsible to the whole touch + accuracy of the BlackBerry port. Initial upstream. + + * WebKitSupport/FatFingers.cpp: Added. + (WebKit): + (BlackBerry::WebKit::FatFingers::fingerRectForPoint): + (BlackBerry::WebKit::hasMousePressListener): + (BlackBerry::WebKit::FatFingers::isElementClickable): + (BlackBerry::WebKit::isFieldWithText): + (BlackBerry::WebKit::distanceBetweenPoints): + (BlackBerry::WebKit::compareDistanceBetweenPoints): + (BlackBerry::WebKit::isValidFrameOwner): + (BlackBerry::WebKit::FatFingers::FatFingers): + (BlackBerry::WebKit::FatFingers::~FatFingers): + (BlackBerry::WebKit::FatFingers::findBestPoint): + (BlackBerry::WebKit::FatFingers::checkFingerIntersection): + (BlackBerry::WebKit::FatFingers::findIntersectingRegions): + (BlackBerry::WebKit::FatFingers::checkForClickableElement): + (BlackBerry::WebKit::FatFingers::checkForText): + (BlackBerry::WebKit::FatFingers::getPaddings): + (BlackBerry::WebKit::FatFingers::nodesFromRect): + (BlackBerry::WebKit::FatFingers::getRelevantInfoFromPoint): + (BlackBerry::WebKit::FatFingers::setSuccessfulFatFingersResult): + * WebKitSupport/FatFingers.h: Added. + (WebCore): + (WebKit): + (FatFingersResult): + (BlackBerry::WebKit::FatFingersResult::FatFingersResult): + (BlackBerry::WebKit::FatFingersResult::reset): + (BlackBerry::WebKit::FatFingersResult::originPosition): + (BlackBerry::WebKit::FatFingersResult::adjustedPosition): + (BlackBerry::WebKit::FatFingersResult::positionWasAdjusted): + (BlackBerry::WebKit::FatFingersResult::isTextInput): + (BlackBerry::WebKit::FatFingersResult::isValid): + (BlackBerry::WebKit::FatFingersResult::validNode): + (BlackBerry::WebKit::FatFingersResult::nodeAsElementIfApplicable): + (FatFingers): + +2012-02-16 Antonio Gomes <agomes@rim.com> + + [BlackBerry] Upstream touch handling related classes + https://bugs.webkit.org/show_bug.cgi?id=78509 + + Reviewed by Adam Treat. + + Initial upstream of the Blackberry specific single touch event + handler class. + + * blackberry/WebKitSupport/TouchEventHandler.cpp: Added. + (WebKit): + (BlackBerry::WebKit::hasMouseMoveListener): + (BlackBerry::WebKit::hasTouchListener): + (BlackBerry::WebKit::elementExpectsMouseEvents): + (BlackBerry::WebKit::shouldConvertTouchToMouse): + (BlackBerry::WebKit::TouchEventHandler::TouchEventHandler): + (BlackBerry::WebKit::TouchEventHandler::~TouchEventHandler): + (BlackBerry::WebKit::TouchEventHandler::shouldSuppressMouseDownOnTouchDown): + [BlackBerry] Upstream touch handling related classes + https://bugs.webkit.org/show_bug.cgi?id=78509 + + Reviewed by Rob Buis. + + InRegionScrollableArea specializes the BlackBerry specific ScrollViewBase, + working as a read-only wrapper object for a scrollable areas in the page. + It is used in our client side to control in-region scrolling (scrollable boxes, + inner frames, etc). + + Initial upstream. + + * WebKitSupport/InRegionScrollableArea.cpp: Added. + (WebKit): + (BlackBerry::WebKit::InRegionScrollableArea::InRegionScrollableArea): + (BlackBerry::WebKit::InRegionScrollableArea::calculateMinimumScrollPosition): + (BlackBerry::WebKit::InRegionScrollableArea::calculateMaximumScrollPosition): + (BlackBerry::WebKit::InRegionScrollableArea::layer): + (BlackBerry): + * WebKitSupport/InRegionScrollableArea.h: Added. + (WebCore): + (WebKit): + (InRegionScrollableArea): + +2012-02-16 Antonio Gomes <agomes@rim.com> + + (BlackBerry::WebKit::TouchEventHandler::touchEventCancel): + (BlackBerry::WebKit::TouchEventHandler::touchHoldEvent): + (BlackBerry::WebKit::TouchEventHandler::handleTouchPoint): + (BlackBerry::WebKit::TouchEventHandler::spellCheck): + (BlackBerry::WebKit::TouchEventHandler::handleFatFingerPressed): + (BlackBerry::WebKit::elementForTapHighlight): + (BlackBerry::WebKit::TouchEventHandler::drawTapHighlight): + * blackberry/WebKitSupport/TouchEventHandler.h: Added. + (WebCore): + (WebKit): + (TouchEventHandler): + (BlackBerry::WebKit::TouchEventHandler::lastFatFingersResult): + (BlackBerry::WebKit::TouchEventHandler::resetLastFatFingersResult): + diff --git a/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.cpp b/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.cpp index 0e9acffd8..b12f49b21 100644 --- a/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.cpp +++ b/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.cpp @@ -61,8 +61,10 @@ #include "WebSettings.h" #include "WebString.h" #include "WindowFeatures.h" + #include <BlackBerryPlatformLog.h> #include <BlackBerryPlatformSettings.h> +#include <BlackBerryPlatformWindow.h> #define DEBUG_OVERFLOW_DETECTION 0 @@ -830,14 +832,4 @@ bool ChromeClientBlackBerry::allowsAcceleratedCompositing() const } #endif -void* ChromeClientBlackBerry::platformWindow() const -{ - return m_webPagePrivate->m_client->window(); -} - -void* ChromeClientBlackBerry::platformCompositingWindow() const -{ - return m_webPagePrivate->m_client->compositingWindow(); -} - } // namespace WebCore diff --git a/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.h b/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.h index 76a715abe..99c8b6062 100644 --- a/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.h +++ b/Source/WebKit/blackberry/WebCoreSupport/ChromeClientBlackBerry.h @@ -148,9 +148,6 @@ public: virtual bool allowsAcceleratedCompositing() const; #endif - virtual void* platformWindow() const; - virtual void* platformCompositingWindow() const; - BlackBerry::WebKit::WebPagePrivate* webPagePrivate() const { return m_webPagePrivate; } private: diff --git a/Source/WebKit/blackberry/WebCoreSupport/EditorClientBlackBerry.cpp b/Source/WebKit/blackberry/WebCoreSupport/EditorClientBlackBerry.cpp new file mode 100644 index 000000000..0e4441d82 --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/EditorClientBlackBerry.cpp @@ -0,0 +1,628 @@ +/* + * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/ + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "EditorClientBlackBerry.h" + +#include "DOMSupport.h" +#include "DumpRenderTreeClient.h" +#include "EditCommand.h" +#include "Frame.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "InputHandler.h" +#include "KeyboardEvent.h" +#include "NotImplemented.h" +#include "Page.h" +#include "PlatformKeyboardEvent.h" +#include "SelectionHandler.h" +#include "WebPage_p.h" +#include "WindowsKeyboardCodes.h" + +using namespace BlackBerry::WebKit; + +namespace WebCore { + +// Arbitrary depth limit for the undo stack, to keep it from using +// unbounded memory. This is the maximum number of distinct undoable +// actions -- unbroken stretches of typed characters are coalesced +// into a single action only when not interrupted by string replacements +// triggered by replaceText calls. +static const size_t maximumUndoStackDepth = 1000; + +EditorClientBlackBerry::EditorClientBlackBerry(WebPagePrivate* webPagePrivate) + : m_webPagePrivate(webPagePrivate) + , m_waitingForCursorFocus(false) + , m_spellCheckState(SpellCheckDefault) + , m_inRedo(false) +{ +} + +void EditorClientBlackBerry::pageDestroyed() +{ + delete this; +} + +bool EditorClientBlackBerry::shouldDeleteRange(Range* range) +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->shouldDeleteDOMRange(range); + return true; +} + +bool EditorClientBlackBerry::shouldShowDeleteInterface(HTMLElement*) +{ + notImplemented(); + return false; +} + +bool EditorClientBlackBerry::smartInsertDeleteEnabled() +{ + notImplemented(); + return false; +} + +bool EditorClientBlackBerry::isSelectTrailingWhitespaceEnabled() +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->isSelectTrailingWhitespaceEnabled(); + return false; +} + +void EditorClientBlackBerry::enableSpellChecking(bool enable) +{ + m_spellCheckState = enable ? SpellCheckDefault : SpellCheckOff; +} + +bool EditorClientBlackBerry::shouldSpellCheckFocusedField() +{ + const Frame* frame = m_webPagePrivate->focusedOrMainFrame(); + if (!frame || !frame->document() || !frame->editor()) + return false; + + const Node* node = frame->document()->focusedNode(); + // NOTE: This logic is taken from EditorClientImpl::shouldSpellcheckByDefault + // If |node| is null, we default to allowing spellchecking. This is done in + // order to mitigate the issue when the user clicks outside the textbox, as a + // result of which |node| becomes null, resulting in all the spell check + // markers being deleted. Also, the Frame will decide not to do spellchecking + // if the user can't edit - so returning true here will not cause any problems + // to the Frame's behavior. + if (!node) + return true; + + // If the field does not support autocomplete, do not do spellchecking. + if (node->isElementNode()) { + const Element* element = static_cast<const Element*>(node); + if (element->hasTagName(HTMLNames::inputTag) && !DOMSupport::elementSupportsAutocomplete(element)) + return false; + } + + // Check if the node disables spell checking directly. + return frame->editor()->isSpellCheckingEnabledInFocusedNode(); +} + +bool EditorClientBlackBerry::isContinuousSpellCheckingEnabled() +{ + if (m_spellCheckState == SpellCheckOff) + return false; + if (m_spellCheckState == SpellCheckOn) + return true; + return shouldSpellCheckFocusedField(); +} + +void EditorClientBlackBerry::toggleContinuousSpellChecking() +{ + // Use the current state to determine how to toggle, if it hasn't + // been explicitly set, it will toggle based on the field type. + if (isContinuousSpellCheckingEnabled()) + m_spellCheckState = SpellCheckOff; + else + m_spellCheckState = SpellCheckOn; +} + +bool EditorClientBlackBerry::isGrammarCheckingEnabled() +{ + notImplemented(); + return false; +} + +void EditorClientBlackBerry::toggleGrammarChecking() +{ + notImplemented(); +} + +int EditorClientBlackBerry::spellCheckerDocumentTag() +{ + notImplemented(); + return 0; +} + +bool EditorClientBlackBerry::shouldBeginEditing(Range* range) +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->shouldBeginEditingInDOMRange(range); + + return m_webPagePrivate->m_inputHandler->shouldAcceptInputFocus(); +} + +bool EditorClientBlackBerry::shouldEndEditing(Range* range) +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->shouldEndEditingInDOMRange(range); + return true; +} + +bool EditorClientBlackBerry::shouldInsertNode(Node* node, Range* range, EditorInsertAction insertAction) +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->shouldInsertNode(node, range, static_cast<int>(insertAction)); + return true; +} + +bool EditorClientBlackBerry::shouldInsertText(const WTF::String& text, Range* range, EditorInsertAction insertAction) +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->shouldInsertText(text, range, static_cast<int>(insertAction)); + return true; +} + +bool EditorClientBlackBerry::shouldChangeSelectedRange(Range* fromRange, Range* toRange, EAffinity affinity, bool stillSelecting) +{ + if (m_webPagePrivate->m_dumpRenderTree) + return m_webPagePrivate->m_dumpRenderTree->shouldChangeSelectedDOMRangeToDOMRangeAffinityStillSelecting(fromRange, toRange, static_cast<int>(affinity), stillSelecting); + + Frame* frame = m_webPagePrivate->focusedOrMainFrame(); + if (frame && frame->document()) { + if (frame->document()->focusedNode() && frame->document()->focusedNode()->hasTagName(HTMLNames::selectTag)) + return false; + + // Update the focus state to re-show the keyboard if needed. + // FIXME, this should be removed and strictly be a show keyboard call if + // focus is active. + if (m_webPagePrivate->m_inputHandler->isInputMode()) + m_webPagePrivate->m_inputHandler->nodeFocused(frame->document()->focusedNode()); + } + + return true; +} + +bool EditorClientBlackBerry::shouldApplyStyle(StylePropertySet*, Range*) +{ + notImplemented(); + return true; +} + +bool EditorClientBlackBerry::shouldMoveRangeAfterDelete(Range*, Range*) +{ + notImplemented(); + return true; +} + +void EditorClientBlackBerry::didBeginEditing() +{ + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didBeginEditing(); +} + +void EditorClientBlackBerry::respondToChangedContents() +{ + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didChange(); +} + +void EditorClientBlackBerry::respondToChangedSelection(Frame* frame) +{ + if (m_waitingForCursorFocus) + m_waitingForCursorFocus = false; + else + m_webPagePrivate->selectionChanged(frame); + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didChangeSelection(); +} + +void EditorClientBlackBerry::didEndEditing() +{ + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didEndEditing(); +} + +void EditorClientBlackBerry::respondToSelectionAppearanceChange() +{ + m_webPagePrivate->m_selectionHandler->selectionPositionChanged(); +} + +void EditorClientBlackBerry::didWriteSelectionToPasteboard() +{ + notImplemented(); +} + +void EditorClientBlackBerry::didSetSelectionTypesForPasteboard() +{ + notImplemented(); +} + +void EditorClientBlackBerry::registerCommandForUndo(PassRefPtr<EditCommand> command) +{ + // Remove the oldest item if we've reached the maximum capacity for the stack. + if (m_undoStack.size() == maximumUndoStackDepth) + m_undoStack.removeFirst(); + + if (!m_inRedo) + m_redoStack.clear(); + + m_undoStack.append(command); +} + +void EditorClientBlackBerry::registerCommandForRedo(PassRefPtr<EditCommand> command) +{ + m_redoStack.append(command); +} + +void EditorClientBlackBerry::clearUndoRedoOperations() +{ + m_undoStack.clear(); + m_redoStack.clear(); +} + +bool EditorClientBlackBerry::canUndo() const +{ + return !m_undoStack.isEmpty(); +} + +bool EditorClientBlackBerry::canRedo() const +{ + return !m_redoStack.isEmpty(); +} + +bool EditorClientBlackBerry::canCopyCut(Frame*, bool defaultValue) const +{ + return defaultValue; +} + +bool EditorClientBlackBerry::canPaste(Frame*, bool defaultValue) const +{ + return defaultValue; +} + +void EditorClientBlackBerry::undo() +{ + if (canUndo()) { + EditCommandStack::iterator back = --m_undoStack.end(); + RefPtr<EditCommand> command(*back); + m_undoStack.remove(back); + + // Unapply will call us back to push this command onto the redo stack. + command->unapply(); + } +} + +void EditorClientBlackBerry::redo() +{ + if (canRedo()) { + EditCommandStack::iterator back = --m_redoStack.end(); + RefPtr<EditCommand> command(*back); + m_redoStack.remove(back); + + ASSERT(!m_inRedo); + m_inRedo = true; + + // Reapply will call us back to push this command onto the undo stack. + command->reapply(); + m_inRedo = false; + } +} + +static const unsigned CtrlKey = 1 << 0; +static const unsigned AltKey = 1 << 1; +static const unsigned ShiftKey = 1 << 2; + +struct KeyDownEntry { + unsigned virtualKey; + unsigned modifiers; + const char* name; +}; + +struct KeyPressEntry { + unsigned charCode; + unsigned modifiers; + const char* name; +}; + +static const KeyDownEntry keyDownEntries[] = { + { VK_LEFT, 0, "MoveLeft" }, + { VK_LEFT, ShiftKey, "MoveLeftAndModifySelection" }, + { VK_LEFT, CtrlKey, "MoveWordLeft" }, + { VK_LEFT, CtrlKey | ShiftKey, "MoveWordLeftAndModifySelection" }, + { VK_RIGHT, 0, "MoveRight" }, + { VK_RIGHT, ShiftKey, "MoveRightAndModifySelection" }, + { VK_RIGHT, CtrlKey, "MoveWordRight" }, + { VK_RIGHT, CtrlKey | ShiftKey, "MoveWordRightAndModifySelection" }, + { VK_UP, 0, "MoveUp" }, + { VK_UP, ShiftKey, "MoveUpAndModifySelection" }, + { VK_DOWN, 0, "MoveDown" }, + { VK_DOWN, ShiftKey, "MoveDownAndModifySelection" }, + { VK_PRIOR, 0, "MovePageUp" }, + { VK_PRIOR, ShiftKey, "MovePageUpAndModifySelection" }, + { VK_NEXT, 0, "MovePageDown" }, + { VK_NEXT, ShiftKey, "MovePageDownAndModifySelection" }, + { VK_HOME, 0, "MoveToBeginningOfLine" }, + { VK_HOME, ShiftKey, "MoveToBeginningOfLineAndModifySelection" }, + { VK_HOME, CtrlKey, "MoveToBeginningOfDocument" }, + { VK_HOME, CtrlKey | ShiftKey, "MoveToBeginningOfDocumentAndModifySelection" }, + { VK_END, 0, "MoveToEndOfLine" }, + { VK_END, ShiftKey, "MoveToEndOfLineAndModifySelection" }, + { VK_END, CtrlKey, "MoveToEndOfDocument" }, + { VK_END, CtrlKey | ShiftKey, "MoveToEndOfDocumentAndModifySelection" }, + + { 'B', CtrlKey, "ToggleBold" }, + { 'I', CtrlKey, "ToggleItalic" }, + { 'U', CtrlKey, "ToggleUnderline" }, + + { VK_BACK, 0, "DeleteBackward" }, + { VK_BACK, ShiftKey, "DeleteBackward" }, + { VK_DELETE, 0, "DeleteForward" }, + { VK_BACK, CtrlKey, "DeleteWordBackward" }, + { VK_DELETE, CtrlKey, "DeleteWordForward" }, + + { 'C', CtrlKey, "Copy" }, + { 'V', CtrlKey, "Paste" }, + { 'V', CtrlKey | ShiftKey, "PasteAndMatchStyle" }, + { 'X', CtrlKey, "Cut" }, + { VK_INSERT, CtrlKey, "Copy" }, + { VK_DELETE, ShiftKey, "Cut" }, + { VK_INSERT, ShiftKey, "Paste" }, + + { 'A', CtrlKey, "SelectAll" }, + { 'Z', CtrlKey, "Undo" }, + { 'Z', CtrlKey | ShiftKey, "Redo" }, + { 'Y', CtrlKey, "Redo" }, + + { VK_TAB, 0, "InsertTab" }, + { VK_TAB, ShiftKey, "InsertBacktab" }, + { VK_RETURN, 0, "InsertNewline" }, + { VK_RETURN, CtrlKey, "InsertNewline" }, + { VK_RETURN, AltKey, "InsertNewline" }, + { VK_RETURN, ShiftKey, "InsertLineBreak" }, + { VK_RETURN, AltKey | ShiftKey, "InsertNewline" }, + +}; + +static const KeyPressEntry keyPressEntries[] = { + { '\t', 0, "InsertTab" }, + { '\t', ShiftKey, "InsertBacktab" }, + { '\r', 0, "InsertNewline" }, + { '\r', CtrlKey, "InsertNewline" }, + { '\r', AltKey, "InsertNewline" }, + { '\r', ShiftKey, "InsertLineBreak" }, + { '\r', AltKey | ShiftKey, "InsertNewline" }, +}; + + +const char* EditorClientBlackBerry::interpretKeyEvent(const KeyboardEvent* event) +{ + ASSERT(event->type() == eventNames().keydownEvent || event->type() == eventNames().keypressEvent); + + static HashMap<int, const char*>* keyDownCommandsMap = 0; + static HashMap<int, const char*>* keyPressCommandsMap = 0; + + if (!keyDownCommandsMap) { + keyDownCommandsMap = new HashMap<int, const char*>; + keyPressCommandsMap = new HashMap<int, const char*>; + + for (size_t i = 0; i < WTF_ARRAY_LENGTH(keyDownEntries); ++i) + keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey, keyDownEntries[i].name); + + for (size_t i = 0; i < WTF_ARRAY_LENGTH(keyPressEntries); ++i) + keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode, keyPressEntries[i].name); + } + + unsigned modifiers = 0; + if (event->shiftKey()) + modifiers |= ShiftKey; + if (event->altKey()) + modifiers |= AltKey; + if (event->ctrlKey()) + modifiers |= CtrlKey; + + if (event->type() == eventNames().keydownEvent) { + int mapKey = modifiers << 16 | event->keyCode(); + return mapKey ? keyDownCommandsMap->get(mapKey) : 0; + } + + int mapKey = modifiers << 16 | event->charCode(); + return mapKey ? keyPressCommandsMap->get(mapKey) : 0; +} + +void EditorClientBlackBerry::handleKeyboardEvent(KeyboardEvent* event) +{ + ASSERT(event); + + const PlatformKeyboardEvent* platformEvent = event->keyEvent(); + if (!platformEvent) + return; + + ASSERT(event->target()->toNode()); + Frame* frame = event->target()->toNode()->document()->frame(); + ASSERT(frame); + + String commandName = interpretKeyEvent(event); + + if (!commandName.isEmpty()) { + if (frame->editor()->command(commandName).execute()) + event->setDefaultHandled(); + return; + } + + if (!frame->editor()->canEdit()) + return; + + // Text insertion commands should only be triggered from keypressEvent. + // There is an assert guaranteeing this in + // EventHandler::handleTextInputEvent. Note that windowsVirtualKeyCode + // is not set for keypressEvent: special keys should have been already + // handled in keydownEvent, which is called first. + if (event->type() != eventNames().keypressEvent) + return; + + // Don't insert null or control characters as they can result in unexpected behaviour. + if (event->charCode() < ' ') + return; + + // Don't insert anything if a modifier is pressed. + if (event->ctrlKey() || event->altKey()) + return; + + if (!platformEvent->text().isEmpty()) { + if (frame->editor()->insertText(platformEvent->text(), event)) + event->setDefaultHandled(); + } +} + +void EditorClientBlackBerry::handleInputMethodKeydown(KeyboardEvent*) +{ + notImplemented(); +} + +void EditorClientBlackBerry::textFieldDidBeginEditing(Element*) +{ + notImplemented(); +} + +void EditorClientBlackBerry::textFieldDidEndEditing(Element*) +{ + notImplemented(); +} + +void EditorClientBlackBerry::textDidChangeInTextField(Element*) +{ + notImplemented(); +} + +bool EditorClientBlackBerry::doTextFieldCommandFromEvent(Element*, KeyboardEvent*) +{ + notImplemented(); + return false; +} + +void EditorClientBlackBerry::textWillBeDeletedInTextField(Element*) +{ + notImplemented(); +} + +void EditorClientBlackBerry::textDidChangeInTextArea(Element*) +{ + notImplemented(); +} + +void EditorClientBlackBerry::ignoreWordInSpellDocument(const WTF::String&) +{ + notImplemented(); +} + +void EditorClientBlackBerry::learnWord(const WTF::String&) +{ + notImplemented(); +} + +void EditorClientBlackBerry::checkSpellingOfString(const UChar* text, int textLength, int* misspellLocation, int* misspellLength) +{ + m_webPagePrivate->m_client->checkSpellingOfString(text, textLength, *misspellLocation, *misspellLength); +} + +WTF::String EditorClientBlackBerry::getAutoCorrectSuggestionForMisspelledWord(const WTF::String& misspelledWord) +{ + notImplemented(); + return WTF::String(); +} + +void EditorClientBlackBerry::checkGrammarOfString(const UChar*, int, WTF::Vector<GrammarDetail, 0u>&, int*, int*) +{ + notImplemented(); +} + +void EditorClientBlackBerry::requestCheckingOfString(SpellChecker*, const TextCheckingRequest&) +{ + notImplemented(); +} + +TextCheckerClient* EditorClientBlackBerry::textChecker() +{ + return this; +} + +void EditorClientBlackBerry::updateSpellingUIWithGrammarString(const WTF::String&, const GrammarDetail&) +{ + notImplemented(); +} + +void EditorClientBlackBerry::updateSpellingUIWithMisspelledWord(const WTF::String&) +{ + notImplemented(); +} + +void EditorClientBlackBerry::showSpellingUI(bool) +{ + notImplemented(); +} + +bool EditorClientBlackBerry::spellingUIIsShowing() +{ + notImplemented(); + return false; +} + +void EditorClientBlackBerry::getGuessesForWord(const WTF::String&, WTF::Vector<WTF::String, 0u>&) +{ + notImplemented(); +} + +void EditorClientBlackBerry::getGuessesForWord(const String&, const String&, Vector<String>&) +{ + notImplemented(); +} + +void EditorClientBlackBerry::willSetInputMethodState() +{ + notImplemented(); +} + +void EditorClientBlackBerry::setInputMethodState(bool active) +{ + Frame* frame = m_webPagePrivate->focusedOrMainFrame(); + // Determines whether or not to provide input assistance. Password fields + // do not have this flag active, so it needs to be overridden. + if (frame && frame->document()) { + if (Node* focusNode = frame->document()->focusedNode()) { + if (!active && focusNode->hasTagName(HTMLNames::inputTag) + && static_cast<HTMLInputElement*>(focusNode)->isPasswordField()) + active = true; + + if (active) { + m_webPagePrivate->m_inputHandler->nodeFocused(focusNode); + return; + } + } + } + // No frame or document or a node that doesn't support IME. + m_webPagePrivate->m_inputHandler->nodeFocused(0); +} + +} // namespace WebCore diff --git a/Source/WebKit/blackberry/WebCoreSupport/EditorClientBlackBerry.h b/Source/WebKit/blackberry/WebCoreSupport/EditorClientBlackBerry.h new file mode 100644 index 000000000..54a310090 --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/EditorClientBlackBerry.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/ + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef EditorClientBlackBerry_h +#define EditorClientBlackBerry_h + +#include "EditorClient.h" +#include "TextCheckerClient.h" + +#include <wtf/Deque.h> + +namespace BlackBerry { +namespace WebKit { +class WebPagePrivate; +} +} + +namespace WebCore { + +class EditorClientBlackBerry : public EditorClient, public TextCheckerClient { +public: + EditorClientBlackBerry(BlackBerry::WebKit::WebPagePrivate*); + virtual void pageDestroyed(); + virtual bool shouldDeleteRange(Range*); + virtual bool shouldShowDeleteInterface(HTMLElement*); + virtual bool smartInsertDeleteEnabled(); + virtual bool isSelectTrailingWhitespaceEnabled(); + virtual bool isContinuousSpellCheckingEnabled(); + virtual void toggleContinuousSpellChecking(); + virtual bool isGrammarCheckingEnabled(); + virtual void toggleGrammarChecking(); + virtual int spellCheckerDocumentTag(); + virtual bool shouldBeginEditing(Range*); + virtual bool shouldEndEditing(Range*); + virtual bool shouldInsertNode(Node*, Range*, EditorInsertAction); + virtual bool shouldInsertText(const String&, Range*, EditorInsertAction); + virtual bool shouldChangeSelectedRange(Range*, Range*, EAffinity, bool); + virtual bool shouldApplyStyle(StylePropertySet*, Range*); + virtual bool shouldMoveRangeAfterDelete(Range*, Range*); + virtual void didBeginEditing(); + virtual void respondToChangedContents(); + virtual void respondToChangedSelection(Frame*); + virtual void respondToSelectionAppearanceChange(); + virtual void didEndEditing(); + virtual void didWriteSelectionToPasteboard(); + virtual void didSetSelectionTypesForPasteboard(); + virtual void registerCommandForUndo(PassRefPtr<EditCommand>); + virtual void registerCommandForRedo(PassRefPtr<EditCommand>); + virtual void clearUndoRedoOperations(); + virtual bool canCopyCut(Frame*, bool) const; + virtual bool canPaste(Frame*, bool) const; + virtual bool canUndo() const; + virtual bool canRedo() const; + virtual void undo(); + virtual void redo(); + virtual const char* interpretKeyEvent(const KeyboardEvent*); + virtual void handleKeyboardEvent(KeyboardEvent*); + virtual void handleInputMethodKeydown(KeyboardEvent*); + virtual void textFieldDidBeginEditing(Element*); + virtual void textFieldDidEndEditing(Element*); + virtual void textDidChangeInTextField(Element*); + virtual bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*); + virtual void textWillBeDeletedInTextField(Element*); + virtual void textDidChangeInTextArea(Element*); + virtual void ignoreWordInSpellDocument(const String&); + virtual void learnWord(const String&); + virtual void checkSpellingOfString(const UChar*, int, int*, int*); + virtual String getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord); + virtual void checkGrammarOfString(const UChar*, int, Vector<GrammarDetail, 0u>&, int*, int*); + virtual void getGuessesForWord(const String&, const String&, Vector<String>&); + virtual void requestCheckingOfString(SpellChecker*, const TextCheckingRequest&); + + virtual TextCheckerClient* textChecker(); + virtual void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&); + virtual void updateSpellingUIWithMisspelledWord(const String&); + virtual void showSpellingUI(bool); + virtual bool spellingUIIsShowing(); + virtual void getGuessesForWord(const String&, Vector<String, 0u>&); + virtual void willSetInputMethodState(); + virtual void setInputMethodState(bool); + + void enableSpellChecking(bool); + +private: + bool shouldSpellCheckFocusedField(); + + BlackBerry::WebKit::WebPagePrivate* m_webPagePrivate; + bool m_waitingForCursorFocus; + + enum SpellCheckState { SpellCheckDefault, SpellCheckOn, SpellCheckOff }; + SpellCheckState m_spellCheckState; + + bool m_inRedo; + + typedef Deque<RefPtr<WebCore::EditCommand> > EditCommandStack; + EditCommandStack m_undoStack; + EditCommandStack m_redoStack; +}; + +} // WebCore + +#endif // EditorClientBlackBerry_h diff --git a/Source/WebKit/blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.cpp b/Source/WebKit/blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.cpp new file mode 100644 index 000000000..afddd51a3 --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.cpp @@ -0,0 +1,1274 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "FrameLoaderClientBlackBerry.h" + +#include "BackForwardController.h" +#include "BackForwardListImpl.h" +#include "BackingStoreClient.h" +#include "BackingStore_p.h" +#include "Base64.h" +#include "CachedImage.h" +#include "Chrome.h" +#include "ChromeClientBlackBerry.h" +#include "ClientExtension.h" +#include "CookieManager.h" +#include "DumpRenderTreeClient.h" +#include "FrameNetworkingContextBlackBerry.h" +#include "FrameView.h" +#include "HTMLFormElement.h" +#include "HTMLHeadElement.h" +#include "HTMLImageElement.h" +#include "HTMLLinkElement.h" +#include "HTMLMediaElement.h" +#include "HTMLMetaElement.h" +#include "HTMLNames.h" +#include "HTMLPlugInElement.h" +#include "HTTPParsers.h" +#include "HistoryItem.h" +#include "IconDatabase.h" +#include "Image.h" +#include "InputHandler.h" +#include "MIMETypeRegistry.h" +#include "NativeImageSkia.h" +#include "NetworkManager.h" +#include "NodeList.h" +#include "Page.h" +#include "PluginView.h" +#include "ProgressTracker.h" +#include "ScopePointer.h" +#include "SharedBuffer.h" +#include "TextEncoding.h" +#include "TouchEventHandler.h" +#if ENABLE(WEBDOM) +#include "WebDOMDocument.h" +#endif +#include "WebPageClient.h" + +#include <BlackBerryPlatformLog.h> +#include <BlackBerryPlatformScreen.h> +#include <JavaScriptCore/APICast.h> +#include <network/FilterStream.h> +#include <network/NetworkRequest.h> + +using WTF::String; +using namespace WebCore; +using namespace BlackBerry::WebKit; + +// This was copied from file "WebKit/Source/WebKit/mac/Misc/WebKitErrors.h". +enum { + WebKitErrorCannotShowMIMEType = 100, + WebKitErrorCannotShowURL = 101, + WebKitErrorFrameLoadInterruptedByPolicyChange = 102, + WebKitErrorCannotUseRestrictedPort = 103, + WebKitErrorCannotFindPlugIn = 200, + WebKitErrorCannotLoadPlugIn = 201, + WebKitErrorJavaUnavailable = 202, + WebKitErrorPluginWillHandleLoad = 203 +}; + +namespace WebCore { + +FrameLoaderClientBlackBerry::FrameLoaderClientBlackBerry() + : m_frame(0) + , m_webPagePrivate(0) + , m_sentReadyToRender(false) + , m_pendingFragmentScrollPolicyFunction(0) + , m_loadingErrorPage(false) + , m_clientRedirectIsPending(false) + , m_childFrameCreationSuppressed(false) + , m_pluginView(0) + , m_hasSentResponseToPlugin(false) + , m_cancelLoadOnNextData(false) +{ + m_deferredJobsTimer = new Timer<FrameLoaderClientBlackBerry>(this, &FrameLoaderClientBlackBerry::deferredJobsTimerFired); +} + +FrameLoaderClientBlackBerry::~FrameLoaderClientBlackBerry() +{ + delete m_deferredJobsTimer; + m_deferredJobsTimer = 0; +} + +int FrameLoaderClientBlackBerry::playerId() const +{ + if (m_webPagePrivate && m_webPagePrivate->m_client) + return m_webPagePrivate->m_client->getInstanceId(); + return 0; +} + +bool FrameLoaderClientBlackBerry::cookiesEnabled() const +{ + return m_webPagePrivate->m_webSettings->areCookiesEnabled(); +} + +void FrameLoaderClientBlackBerry::dispatchDidAddBackForwardItem(HistoryItem* item) const +{ + // Inform the client that the back/forward list has changed. + invalidateBackForwardList(); +} + +void FrameLoaderClientBlackBerry::dispatchDidRemoveBackForwardItem(HistoryItem* item) const +{ + invalidateBackForwardList(); +} + +void FrameLoaderClientBlackBerry::dispatchDidChangeBackForwardIndex() const +{ + invalidateBackForwardList(); +} + +void FrameLoaderClientBlackBerry::dispatchDidChangeLocationWithinPage() +{ + if (!isMainFrame()) + return; + + String url = m_frame->document()->url().string(); + String token = m_frame->loader()->documentLoader()->request().token(); + + m_webPagePrivate->m_client->notifyLoadToAnchor(url.characters(), url.length(), token.characters(), token.length()); +} + +void FrameLoaderClientBlackBerry::dispatchDidPushStateWithinPage() +{ + // FIXME: As a workaround we abuse anchor navigation to achieve history push. See PR #119779 for more details. + dispatchDidChangeLocationWithinPage(); +} + +void FrameLoaderClientBlackBerry::dispatchDidReplaceStateWithinPage() +{ + // FIXME: As a workaround we abuse anchor navigation to achieve history replace. See PR #119779 for more details. + dispatchDidChangeLocationWithinPage(); +} + +void FrameLoaderClientBlackBerry::dispatchDidPopStateWithinPage() +{ + // Not needed. +} + +void FrameLoaderClientBlackBerry::dispatchDidCancelClientRedirect() +{ + m_clientRedirectIsPending = false; +} + +void FrameLoaderClientBlackBerry::dispatchWillPerformClientRedirect(const KURL&, double, double) +{ + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didDispatchWillPerformClientRedirect(); + + m_clientRedirectIsPending = true; +} + +void FrameLoaderClientBlackBerry::dispatchDecidePolicyForResponse(FramePolicyFunction function, const ResourceResponse& response, const ResourceRequest& request) +{ + // FIXME: What should we do for HTTP status code 204 and 205 and "application/zip"? + PolicyAction policy = PolicyIgnore; + + if (contentDispositionType(response.httpHeaderField("Content-Disposition")) == ContentDispositionAttachment + || request.forceDownload()) + policy = PolicyDownload; + else if (canShowMIMEType(response.mimeType())) + policy = PolicyUse; + else if ((ResourceRequest::TargetIsMainFrame == request.targetType()) + && m_webPagePrivate->m_client->downloadAllowed(request.url().string().utf8().data())) + policy = PolicyDownload; + + (m_frame->loader()->policyChecker()->*function)(policy); +} + +void FrameLoaderClientBlackBerry::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request, PassRefPtr<FormState>) +{ + PolicyAction decision = PolicyUse; + + const KURL& url = request.url(); + + // Fragment scrolls on the same page should always be handled internally. + // (Only count as a fragment scroll if we are scrolling to a #fragment url, not back to the top, and reloading + // the same url is not a fragment scroll even if it has a #fragment.) + const KURL& currentUrl = m_frame->document()->url(); + bool isFragmentScroll = url.hasFragmentIdentifier() && url != currentUrl && equalIgnoringFragmentIdentifier(currentUrl, url); + if (decision == PolicyUse) + decision = decidePolicyForExternalLoad(request, isFragmentScroll); + + // Let the client have a chance to say whether this navigation should + // be ignored or not. + BlackBerry::Platform::NetworkRequest platformRequest; + request.initializePlatformRequest(platformRequest, false /*isInitial*/); + if (isMainFrame() && !m_webPagePrivate->m_client->acceptNavigationRequest( + platformRequest, BlackBerry::Platform::NavigationType(action.type()))) { + if (action.type() == NavigationTypeFormSubmitted + || action.type() == NavigationTypeFormResubmitted) + m_frame->loader()->resetMultipleFormSubmissionProtection(); + + if (action.type() == NavigationTypeLinkClicked && url.hasFragmentIdentifier()) { + ResourceRequest emptyRequest; + m_frame->loader()->activeDocumentLoader()->setLastCheckedRequest(emptyRequest); + } + decision = PolicyIgnore; + } + + // If we abort here, dispatchDidCancelClientRedirect will not be called. + // So call it by hand. + if (decision == PolicyIgnore) + dispatchDidCancelClientRedirect(); + + (m_frame->loader()->policyChecker()->*function)(decision); + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didDecidePolicyForNavigationAction(action, request); +} + +void FrameLoaderClientBlackBerry::delayPolicyCheckUntilFragmentExists(const String& fragment, FramePolicyFunction function) +{ + ASSERT(isMainFrame()); + + if (m_webPagePrivate->loadState() < WebPagePrivate::Finished && !m_frame->document()->findAnchor(fragment)) { + // Tell the client we need more data, in case the fragment exists but is being held back. + m_webPagePrivate->m_client->needMoreData(); + m_pendingFragmentScrollPolicyFunction = function; + m_pendingFragmentScroll = fragment; + return; + } + + (m_frame->loader()->policyChecker()->*function)(PolicyUse); +} + +void FrameLoaderClientBlackBerry::cancelPolicyCheck() +{ + m_pendingFragmentScrollPolicyFunction = 0; + m_pendingFragmentScroll = String(); +} + +void FrameLoaderClientBlackBerry::doPendingFragmentScroll() +{ + if (m_pendingFragmentScroll.isNull()) + return; + + // Make sure to clear the pending members first to avoid recursion. + String fragment = m_pendingFragmentScroll; + m_pendingFragmentScroll = String(); + + FramePolicyFunction function = m_pendingFragmentScrollPolicyFunction; + m_pendingFragmentScrollPolicyFunction = 0; + + delayPolicyCheckUntilFragmentExists(fragment, function); +} + +void FrameLoaderClientBlackBerry::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request, PassRefPtr<FormState>, const String& frameName) +{ + if (request.isRequestedByPlugin() && ScriptController::processingUserGesture() && !m_webPagePrivate->m_pluginMayOpenNewTab) + (m_frame->loader()->policyChecker()->*function)(PolicyIgnore); + + // A new window can never be a fragment scroll. + PolicyAction decision = decidePolicyForExternalLoad(request, false); + // Let the client have a chance to say whether this navigation should + // be ignored or not. + BlackBerry::Platform::NetworkRequest platformRequest; + request.initializePlatformRequest(platformRequest, false /*isInitial*/); + if (isMainFrame() && !m_webPagePrivate->m_client->acceptNavigationRequest( + platformRequest, BlackBerry::Platform::NavigationType(action.type()))) { + if (action.type() == NavigationTypeFormSubmitted || action.type() == NavigationTypeFormResubmitted) + m_frame->loader()->resetMultipleFormSubmissionProtection(); + + if (action.type() == NavigationTypeLinkClicked && request.url().hasFragmentIdentifier()) { + ResourceRequest emptyRequest; + m_frame->loader()->activeDocumentLoader()->setLastCheckedRequest(emptyRequest); + } + decision = PolicyIgnore; + } + + (m_frame->loader()->policyChecker()->*function)(decision); +} + +void FrameLoaderClientBlackBerry::committedLoad(DocumentLoader* loader, const char* data, int length) +{ + // The structure of this code may seem...a bit odd. It's structured with two checks on the state + // of m_pluginView because it's actually receivedData that may cause the request to re-direct data + // to a PluginView. This is because receivedData may decide to create a PluginDocument containing + // a PluginView. The PluginView will request that the main resource for the frame be redirected + // to the PluginView. So after receivedData has been called, this code needs to check whether + // re-direction to a PluginView has been requested and pass the same data on to the PluginView. + // Thereafter, all data will be re-directed to the PluginView; i.e., no additional data will go + // to receivedData. + + if (!m_pluginView) { + const String& textEncoding = loader->response().textEncodingName(); + receivedData(data, length, textEncoding); + } + + if (m_pluginView) { + if (!m_hasSentResponseToPlugin) { + m_pluginView->didReceiveResponse(loader->response()); + m_hasSentResponseToPlugin = true; + } + + if (!m_pluginView) + return; + + m_pluginView->didReceiveData(data, length); + } +} + +PassRefPtr<Widget> FrameLoaderClientBlackBerry::createPlugin(const IntSize& pluginSize, + HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, + const Vector<String>& paramValues, const String& mimeTypeIn, bool loadManually) +{ + String mimeType(mimeTypeIn); + if (mimeType.isEmpty()) { + mimeType = MIMETypeRegistry::getMIMETypeForPath(url.path()); + mimeType = WebSettings::getNormalizedMIMEType(mimeType); + if (mimeType != "application/x-shockwave-flash") + mimeType = mimeTypeIn; + } + + if (mimeType == "application/x-shockwave-flash" || mimeType == "application/jnext-scriptable-plugin") + return PluginView::create(m_frame, pluginSize, element, url, paramNames, paramValues, mimeType, loadManually); + + // If it's not the plugin type we support, try load directly from browser. + if (m_frame->loader() && m_frame->loader()->subframeLoader() && !url.isNull()) + m_frame->loader()->subframeLoader()->requestFrame(element, url, String()); + + return 0; +} + +void FrameLoaderClientBlackBerry::redirectDataToPlugin(Widget* pluginWidget) +{ + ASSERT(!m_pluginView); + m_pluginView = static_cast<PluginView*>(pluginWidget); + m_hasSentResponseToPlugin = false; +} + +void FrameLoaderClientBlackBerry::receivedData(const char* data, int length, const String& textEncoding) +{ + if (!m_frame) + return; + + if (m_cancelLoadOnNextData) { + m_frame->loader()->activeDocumentLoader()->stopLoading(); + m_frame->loader()->documentLoader()->writer()->end(); + m_cancelLoadOnNextData = false; + return; + } + + // Set the encoding. This only needs to be done once, but it's harmless to do it again later. + String encoding = m_frame->loader()->documentLoader()->overrideEncoding(); + bool userChosen = !encoding.isNull(); + if (encoding.isNull()) + encoding = textEncoding; + m_frame->loader()->documentLoader()->writer()->setEncoding(encoding, userChosen); + m_frame->loader()->documentLoader()->writer()->addData(data, length); +} + +void FrameLoaderClientBlackBerry::finishedLoading(DocumentLoader* loader) +{ + if (m_pluginView) { + m_pluginView->didFinishLoading(); + m_pluginView = 0; + m_hasSentResponseToPlugin = false; + } else { + // Telling the frame we received some data and passing 0 as the data is our + // way to get work done that is normally done when the first bit of data is + // received, even for the case of a document with no data (like about:blank). + committedLoad(loader, 0, 0); + } +} + +PassRefPtr<DocumentLoader> FrameLoaderClientBlackBerry::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData) +{ + // Make a copy of the request with the token from the original request for this frame + // (unless it already has a token, in which case the request came from the client). + ResourceRequest newRequest(request); + if (m_frame && m_frame->loader() && m_frame->loader()->documentLoader()) { + const ResourceRequest& originalRequest = m_frame->loader()->documentLoader()->originalRequest(); + if (request.token().isNull() && !originalRequest.token().isNull()) + newRequest.setToken(originalRequest.token()); + } + + // FIXME: This should probably be shared. + RefPtr<DocumentLoader> loader = DocumentLoader::create(newRequest, substituteData); + if (substituteData.isValid()) + loader->setDeferMainResourceDataLoad(false); + return loader.release(); +} + +void FrameLoaderClientBlackBerry::frameLoaderDestroyed() +{ + delete this; +} + +void FrameLoaderClientBlackBerry::transitionToCommittedForNewPage() +{ + m_cancelLoadOnNextData = false; + + // In Frame::createView, Frame's FrameView object is set to 0 and recreated. + // This operation is not atomic, and an attempt to blit contents might happen + // in the backing store from another thread (see BackingStorePrivate::blitContents method), + // so we suspend and resume screen update to make sure we do not get a invalid FrameView + // state. + BackingStoreClient* backingStoreClientForFrame = m_webPagePrivate->backingStoreClientForFrame(m_frame); + if (backingStoreClientForFrame) + backingStoreClientForFrame->backingStore()->d->suspendScreenAndBackingStoreUpdates(); + + // We are navigating away from this document, so clean up any footprint we might have. + if (m_frame->document()) + m_webPagePrivate->clearDocumentData(m_frame->document()); + + Color backgroundColor(m_webPagePrivate->m_webSettings->backgroundColor()); + + m_frame->createView(m_webPagePrivate->viewportSize(), /* viewport */ + backgroundColor, /* background color */ + backgroundColor.hasAlpha(), /* is transparent */ + m_webPagePrivate->actualVisibleSize(), /* fixed reported size */ + m_webPagePrivate->fixedLayoutSize(), /* fixed layout size */ + m_webPagePrivate->useFixedLayout(), /* use fixed layout */ + ScrollbarAlwaysOff, /* hor mode */ + true, /* lock the mode */ + ScrollbarAlwaysOff, /* ver mode */ + true); /* lock the mode */ + + if (backingStoreClientForFrame) + backingStoreClientForFrame->backingStore()->d->resumeScreenAndBackingStoreUpdates(BackingStore::None); + m_frame->view()->updateCanHaveScrollbars(); + + if (isMainFrame()) { + // Since the mainframe has a tiled backingstore request to receive all update + // rects instead of the default which just sends update rects for currently + // visible viewport. + m_frame->view()->setPaintsEntireContents(true); + } +} + +String FrameLoaderClientBlackBerry::userAgent(const KURL&) +{ + return m_webPagePrivate->m_webSettings->userAgentString(); +} + +bool FrameLoaderClientBlackBerry::canHandleRequest(const ResourceRequest&) const +{ + // FIXME: Stub. + return true; +} + +bool FrameLoaderClientBlackBerry::canShowMIMEType(const String& mimeTypeIn) const +{ + // Get normalized type. + String mimeType = WebSettings::getNormalizedMIMEType(mimeTypeIn); + + // FIXME: Seems no other port checks empty MIME type in this function. Should we do that? + return MIMETypeRegistry::isSupportedImageMIMEType(mimeType) || MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType) + || MIMETypeRegistry::isSupportedMediaMIMEType(mimeType) || WebSettings::isSupportedObjectMIMEType(mimeType) + || (mimeType == "application/x-shockwave-flash"); +} + +bool FrameLoaderClientBlackBerry::canShowMIMETypeAsHTML(const String&) const +{ + // FIXME: Stub. + return true; +} + +bool FrameLoaderClientBlackBerry::isMainFrame() const +{ + return m_frame == m_webPagePrivate->m_mainFrame; +} + +void FrameLoaderClientBlackBerry::dispatchDidStartProvisionalLoad() +{ + if (isMainFrame()) + m_webPagePrivate->setLoadState(WebPagePrivate::Provisional); + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didStartProvisionalLoadForFrame(m_frame); +} + +void FrameLoaderClientBlackBerry::dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse& response) +{ + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didReceiveResponseForFrame(m_frame, response); +} + +void FrameLoaderClientBlackBerry::dispatchDidReceiveTitle(const StringWithDirection& title) +{ + if (isMainFrame()) + m_webPagePrivate->m_client->setPageTitle(title.string().characters(), title.string().length()); + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didReceiveTitleForFrame(title.string(), m_frame); +} + +void FrameLoaderClientBlackBerry::setTitle(const StringWithDirection& /*title*/, const KURL& /*url*/) +{ + // Used by Apple WebKit to update the title of an existing history item. + // QtWebKit doesn't accomodate this on history items. If it ever does, + // it should be privateBrowsing-aware. For now, we are just passing + // globalhistory layout tests. + // FIXME: Use direction of title. + notImplemented(); +} + +void FrameLoaderClientBlackBerry::dispatchDidCommitLoad() +{ + // FIXME: Do we need to find a replacement for m_frame->document()->setExtraLayoutDelay(250);? + + if (isMainFrame()) { + m_webPagePrivate->setLoadState(WebPagePrivate::Committed); + + String originalUrl = m_frame->loader()->documentLoader()->originalRequest().url().string(); + String url = m_frame->loader()->documentLoader()->request().url().string(); + String token = m_frame->loader()->documentLoader()->request().token(); + + // Notify the client that the load succeeded or failed (if it failed, this + // is actually committing the error page, which was set through + // SubstituteData in dispatchDidFailProvisionalLoad). + if (m_loadingErrorPage) { + m_loadingErrorPage = false; + m_webPagePrivate->m_client->notifyLoadFailedBeforeCommit( + originalUrl.characters(), originalUrl.length(), + url.characters(), url.length(), token.characters(), token.length()); + } else { + m_webPagePrivate->m_client->notifyLoadCommitted( + originalUrl.characters(), originalUrl.length(), + url.characters(), url.length(), token.characters(), token.length()); + } + } + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didCommitLoadForFrame(m_frame); +} + +void FrameLoaderClientBlackBerry::dispatchDidHandleOnloadEvents() +{ + m_webPagePrivate->m_client->notifyDocumentOnLoad(); + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didHandleOnloadEventsForFrame(m_frame); +} + +void FrameLoaderClientBlackBerry::dispatchDidFinishLoad() +{ + didFinishOrFailLoading(ResourceError()); + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didFinishLoadForFrame(m_frame); + + if (!isMainFrame() || m_webPagePrivate->m_webSettings->isEmailMode() + || !m_frame->document() || !m_frame->document()->head()) + return; + + HTMLHeadElement* headElement = m_frame->document()->head(); + // FIXME: Handle NOSCRIPT special case? + + // Process document metadata. + RefPtr<NodeList> nodeList = headElement->getElementsByTagName(HTMLNames::metaTag.localName()); + unsigned int size = nodeList->length(); + ScopeArray<WebString> headers; + + // This may allocate more space than needed since not all meta elements will be http-equiv. + headers.reset(new WebString[2 * size]); + unsigned headersLength = 0; + + for (unsigned i = 0; i < size; ++i) { + HTMLMetaElement* metaElement = static_cast<HTMLMetaElement*>(nodeList->item(i)); + if (WTF::equalIgnoringCase(metaElement->name(), "apple-mobile-web-app-capable") + && WTF::equalIgnoringCase(metaElement->content().stripWhiteSpace(), "yes")) + m_webPagePrivate->m_client->setWebAppCapable(); + else { + String httpEquiv = metaElement->httpEquiv().stripWhiteSpace(); + String content = metaElement->content().stripWhiteSpace(); + + if (!httpEquiv.isNull() && !content.isNull()) { + headers[headersLength++] = httpEquiv; + headers[headersLength++] = content; + } + } + } + + if (headersLength > 0) + m_webPagePrivate->m_client->setMetaHeaders(headers, headersLength); + + nodeList = headElement->getElementsByTagName(HTMLNames::linkTag.localName()); + size = nodeList->length(); + + for (unsigned i = 0; i < size; ++i) { + HTMLLinkElement* linkElement = static_cast<HTMLLinkElement*>(nodeList->item(i)); + String href = linkElement->href().string(); + if (!href.isEmpty()) { + String title = linkElement->title(); + + if (WTF::equalIgnoringCase(linkElement->rel(), "apple-touch-icon")) + m_webPagePrivate->m_client->setLargeIcon(href.latin1().data()); + else if (WTF::equalIgnoringCase(linkElement->rel(), "search")) { + if (WTF::equalIgnoringCase(linkElement->type(), "application/opensearchdescription+xml")) + m_webPagePrivate->m_client->setSearchProviderDetails(title.utf8().data(), href.utf8().data()); + } else if (WTF::equalIgnoringCase(linkElement->rel(), "alternate") + && (WTF::equalIgnoringCase(linkElement->type(), "application/rss+xml") + || WTF::equalIgnoringCase(linkElement->type(), "application/atom+xml"))) + m_webPagePrivate->m_client->setAlternateFeedDetails(title.utf8().data(), href.utf8().data()); + } + } +} + +void FrameLoaderClientBlackBerry::dispatchDidFinishDocumentLoad() +{ + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didFinishDocumentLoadForFrame(m_frame); + notImplemented(); +} + +void FrameLoaderClientBlackBerry::dispatchDidFailLoad(const ResourceError& error) +{ + didFinishOrFailLoading(error); + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didFailLoadForFrame(m_frame); +} + +void FrameLoaderClientBlackBerry::didFinishOrFailLoading(const ResourceError& error) +{ + // FIXME: Do we need to find a replacement for m_frame->document()->setExtraLayoutDelay(0);? + + // If we have finished loading a page through history navigation, any + // attempt to go back to that page through an automatic redirect should be + // denied to avoid redirect loops. So save the history navigation urls to + // check later. (If this was not a history navigation, + // m_historyNavigationSourceURLs will be empty, and we should save that + // too.) + m_redirectURLsToSkipDueToHistoryNavigation.swap(m_historyNavigationSourceURLs); + + // History navigation is finished so clear the history navigation url. + m_historyNavigationSourceURLs.clear(); + + if (isMainFrame()) { + m_loadError = error; + m_webPagePrivate->setLoadState(error.isNull() ? WebPagePrivate::Finished : WebPagePrivate::Failed); + } +} + +void FrameLoaderClientBlackBerry::dispatchDidFailProvisionalLoad(const ResourceError& error) +{ + if (isMainFrame()) { + m_loadError = error; + m_webPagePrivate->setLoadState(WebPagePrivate::Failed); + + if (error.domain() == ResourceError::platformErrorDomain + && (error.errorCode() == BlackBerry::Platform::FilterStream::StatusErrorAlreadyHandled)) { + // Error has already been displayed by client. + return; + } + + if (error.domain().isEmpty() && !error.errorCode() && error.failingURL().isEmpty() && error.localizedDescription().isEmpty()) { + // Don't try to display empty errors returned from the unimplemented error functions in FrameLoaderClientBlackBerry - there's nothing to display anyway. + return; + } + } + + if (m_webPagePrivate->m_dumpRenderTree) + m_webPagePrivate->m_dumpRenderTree->didFailProvisionalLoadForFrame(m_frame); + + if (!isMainFrame()) + return; + + String errorPage = m_webPagePrivate->m_client->getErrorPage(error.errorCode() + , error.localizedDescription().isEmpty() ? "" : error.localizedDescription().utf8().data() + , error.failingURL().isEmpty() ? "" : error.failingURL().utf8().data()); + + // Make sure we're still in the provisionalLoad state - getErrorPage runs a + // nested event loop while it's waiting for client resources to load so + // there's a small window for the user to hit stop. + if (m_frame->loader()->provisionalDocumentLoader()) { + SubstituteData errorData(utf8Buffer(errorPage), "text/html", "utf-8", KURL(KURL(), error.failingURL())); + + ResourceRequest originalRequest = m_frame->loader()->provisionalDocumentLoader()->originalRequest(); + + // Loading using SubstituteData will replace the original request with our + // error data. This must be done within dispatchDidFailProvisionalLoad, + // and do NOT call stopAllLoaders first, because the loader checks the + // provisionalDocumentLoader to decide the load type; if called any other + // way, the error page is added to the end of the history instead of + // replacing the failed load. + // + // If this comes from a back/forward navigation, we need to save the current viewstate + // to original historyitem, and prevent the restore of view state to the error page. + if (isBackForwardLoadType(m_frame->loader()->loadType())) { + m_frame->loader()->history()->saveScrollPositionAndViewStateToItem(m_frame->loader()->history()->currentItem()); + ASSERT(m_frame->loader()->history()->provisionalItem()); + m_frame->loader()->history()->provisionalItem()->viewState().shouldSaveViewState = false; + } + m_loadingErrorPage = true; + m_frame->loader()->load(originalRequest, errorData, false); + } +} + +void FrameLoaderClientBlackBerry::dispatchWillSubmitForm(FramePolicyFunction function, PassRefPtr<FormState>) +{ + // FIXME: Stub. + (m_frame->loader()->policyChecker()->*function)(PolicyUse); +} + +PassRefPtr<Frame> FrameLoaderClientBlackBerry::createFrame(const KURL& url, const String& name + , HTMLFrameOwnerElement* ownerElement, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) +{ + if (!m_webPagePrivate) + return 0; + + if (m_childFrameCreationSuppressed) + return 0; + + FrameLoaderClientBlackBerry* frameLoaderClient = new FrameLoaderClientBlackBerry(); + RefPtr<Frame> childFrame = Frame::create(m_frame->page(), ownerElement, frameLoaderClient); + frameLoaderClient->setFrame(childFrame.get(), m_webPagePrivate); + + // Initialize FrameView. + RefPtr<FrameView> frameView = FrameView::create(childFrame.get()); + childFrame->setView(frameView.get()); + if (!allowsScrolling) + frameView->setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff); + if (marginWidth != -1) + frameView->setMarginWidth(marginWidth); + if (marginHeight != -1) + frameView->setMarginHeight(marginHeight); + + childFrame->tree()->setName(name); + m_frame->tree()->appendChild(childFrame); + childFrame->init(); + + if (!childFrame->tree()->parent()) + return 0; + + BackingStoreClient::create(childFrame.get(), m_frame, m_webPagePrivate->m_webPage); + + m_frame->loader()->loadURLIntoChildFrame(url, referrer, childFrame.get()); + + if (!childFrame->tree()->parent()) + return 0; + + return childFrame.release(); +} + +void FrameLoaderClientBlackBerry::didTransferChildFrameToNewDocument(Page* /*oldPage*/) +{ + Page* newPage = m_frame->page(); + m_webPagePrivate = static_cast<ChromeClientBlackBerry*>(newPage->chrome()->client())->webPagePrivate(); +} + +void FrameLoaderClientBlackBerry::transferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*) +{ + notImplemented(); +} + +ObjectContentType FrameLoaderClientBlackBerry::objectContentType(const KURL& url, const String& mimeTypeIn, bool shouldPreferPlugInsForImages) +{ + String mimeType = mimeTypeIn; + if (mimeType.isEmpty()) + mimeType = MIMETypeRegistry::getMIMETypeForPath(url.path()); + + // Get mapped type. + mimeType = WebSettings::getNormalizedMIMEType(mimeType); + + ObjectContentType defaultType = FrameLoader::defaultObjectContentType(url, mimeType, shouldPreferPlugInsForImages); + if (defaultType != ObjectContentNone) + return defaultType; + + if (WebSettings::isSupportedObjectMIMEType(mimeType)) + return ObjectContentOtherPlugin; + + return ObjectContentNone; +} + +void FrameLoaderClientBlackBerry::dispatchWillClose() +{ + m_webPagePrivate->m_inputHandler->frameUnloaded(m_frame); +} + +void FrameLoaderClientBlackBerry::setMainDocumentError(DocumentLoader*, const ResourceError& error) +{ + if (!m_pluginView) + return; + + m_pluginView->didFail(error); + m_pluginView = 0; + m_hasSentResponseToPlugin = false; +} + +void FrameLoaderClientBlackBerry::postProgressStartedNotification() +{ + if (!isMainFrame()) + return; + + // New load started, so clear the error. + m_loadError = ResourceError(); + m_sentReadyToRender = false; + m_webPagePrivate->m_client->notifyLoadStarted(); +} + +void FrameLoaderClientBlackBerry::postProgressEstimateChangedNotification() +{ + if (!isMainFrame() || !m_frame->page()) + return; + + m_webPagePrivate->m_client->notifyLoadProgress(m_frame->page()->progress()->estimatedProgress() * 100); +} + +void FrameLoaderClientBlackBerry::dispatchDidFirstVisuallyNonEmptyLayout() +{ + if (!isMainFrame()) + return; + + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelInfo, "dispatchDidFirstVisuallyNonEmptyLayout"); + + readyToRender(true); + + // FIXME: We shouldn't be getting here if we are not in the Committed state but we are + // so we can not assert on that right now. But we only want to do this on load. + // RIM Bug #555 + if (m_webPagePrivate->loadState() == WebPagePrivate::Committed) { + m_webPagePrivate->zoomToInitialScaleOnLoad(); // Set the proper zoom level first. + m_webPagePrivate->m_backingStore->d->clearVisibleZoom(); // Clear the visible zoom since we're explicitly rendering+blitting below. + m_webPagePrivate->m_backingStore->d->renderVisibleContents(); + } + + m_webPagePrivate->m_client->notifyFirstVisuallyNonEmptyLayout(); +} + +void FrameLoaderClientBlackBerry::postProgressFinishedNotification() +{ + if (!isMainFrame()) + return; + + // Empty pages will never have called + // dispatchDidFirstVisuallyNonEmptyLayout, since they're visually empty, so + // we may need to call readyToRender now. + readyToRender(false); + + // FIXME: Send up a real status code. + m_webPagePrivate->m_client->notifyLoadFinished(m_loadError.isNull() ? 0 : -1); + + // Notify plugins that are waiting for the page to fully load before starting that + // the load has completed. + m_webPagePrivate->notifyPageOnLoad(); +} + +void FrameLoaderClientBlackBerry::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world) +{ + if (world != mainThreadNormalWorld()) + return; + + // Provide the extension object first in case the client or others want to use it. + // FIXME: Conditionally attach extension object based on some flag or whether or not we + // are browser or something else. + attachExtensionObjectToFrame(m_frame, m_webPagePrivate->m_client); + + m_webPagePrivate->m_client->notifyWindowObjectCleared(); + + if (m_webPagePrivate->m_dumpRenderTree) { + JSGlobalContextRef context = toGlobalRef(m_frame->script()->globalObject(mainThreadNormalWorld())->globalExec()); + JSObjectRef windowObject = toRef(m_frame->script()->globalObject(mainThreadNormalWorld())); + ASSERT(windowObject); + m_webPagePrivate->m_dumpRenderTree->didClearWindowObjectInWorld(world, context, windowObject); + } +} + +bool FrameLoaderClientBlackBerry::shouldGoToHistoryItem(HistoryItem*) const +{ + return true; +} + +bool FrameLoaderClientBlackBerry::shouldStopLoadingForHistoryItem(HistoryItem*) const +{ + return true; +} + +void FrameLoaderClientBlackBerry::invalidateBackForwardList() const +{ + notifyBackForwardListChanged(); +} + +void FrameLoaderClientBlackBerry::notifyBackForwardListChanged() const +{ + BackForwardListImpl* backForwardList = static_cast<BackForwardListImpl*>(m_webPagePrivate->m_page->backForward()->client()); + ASSERT(backForwardList); + + unsigned listSize = backForwardList->entries().size(); + unsigned currentIndex = backForwardList->backListCount(); + m_webPagePrivate->m_client->resetBackForwardList(listSize, currentIndex); +} + +Frame* FrameLoaderClientBlackBerry::dispatchCreatePage(const NavigationAction& navigation) +{ + WebPage* webPage = m_webPagePrivate->m_client->createWindow(0, 0, -1, -1, WebPageClient::FlagWindowDefault, navigation.url().string(), WebString()); + if (!webPage) + return 0; + + return webPage->d->m_page->mainFrame(); +} + +void FrameLoaderClientBlackBerry::detachedFromParent2() +{ + BackingStoreClient* backingStoreClientForFrame = m_webPagePrivate->backingStoreClientForFrame(m_frame); + if (backingStoreClientForFrame) { + delete backingStoreClientForFrame; + backingStoreClientForFrame = 0; + } + + if (m_frame->document()) + m_webPagePrivate->clearDocumentData(m_frame->document()); + + m_webPagePrivate->m_inputHandler->frameUnloaded(m_frame); + m_webPagePrivate->m_client->notifyFrameDetached(m_frame); +} + +void FrameLoaderClientBlackBerry::dispatchWillSendRequest(DocumentLoader* docLoader, long unsigned int, ResourceRequest& request, const ResourceResponse&) +{ + // If the request is being loaded by the provisional document loader, then + // it is a new top level request which has not been commited. + bool isMainResourceLoad = docLoader && docLoader == docLoader->frameLoader()->provisionalDocumentLoader(); + + // Any processing which is done for all loads (both main and subresource) should go here. + BlackBerry::Platform::NetworkRequest platformRequest; + request.initializePlatformRequest(platformRequest, false /*isInitial*/); + m_webPagePrivate->m_client->populateCustomHeaders(platformRequest); + const BlackBerry::Platform::NetworkRequest::HeaderList& headerLists = platformRequest.getHeaderListRef(); + for (BlackBerry::Platform::NetworkRequest::HeaderList::const_iterator it = headerLists.begin(); it != headerLists.end(); ++it) { + std::string headerString = it->first; + std::string headerValueString = it->second; + request.setHTTPHeaderField(String(headerString.c_str()), String(headerValueString.c_str())); + } + if (cookiesEnabled()) { + String cookiePairs = cookieManager().getCookie(request.url(), WithHttpOnlyCookies); + if (!cookiePairs.isEmpty()) { + // We only modify the WebCore request to make the cookies visible in inspector. + request.setHTTPHeaderField(String("Cookie"), cookiePairs); + } + } + if (!isMainResourceLoad) { + // Do nothing for now. + // Any processing which is done only for subresources should go here. + return; + } + + // All processing beyond this point is done only for main resource loads. + + if (m_clientRedirectIsPending && isMainFrame()) { + String originalUrl = m_frame->document()->url().string(); + String finalUrl = request.url().string(); + + m_webPagePrivate->m_client->notifyClientRedirect(originalUrl.characters(), originalUrl.length(), + finalUrl.characters(), finalUrl.length()); + } + + // FIXME: Update the request type. See PR #119792. + if (docLoader->frameLoader()->isLoadingMainFrame()) + request.setTargetType(ResourceRequest::TargetIsMainFrame); + else + request.setTargetType(ResourceRequest::TargetIsSubframe); + + FrameLoader* loader = m_frame->loader(); + ASSERT(loader); + if (isBackForwardLoadType(loader->loadType())) { + // Do not use the passed DocumentLoader because it is the loader that + // will be used for the new request (the DESTINATION of the history + // navigation - we want to use the current DocumentLoader to record the + // SOURCE). + DocumentLoader* docLoader = m_frame->loader()->documentLoader(); + ASSERT(docLoader); + m_historyNavigationSourceURLs.add(docLoader->url()); + m_historyNavigationSourceURLs.add(docLoader->originalURL()); + } +} + +void FrameLoaderClientBlackBerry::loadIconExternally(const String& originalPageUrl, const String& finalPageUrl, const String& iconUrl) +{ + m_webPagePrivate->m_client->setIconForUrl(originalPageUrl.utf8().data(), finalPageUrl.utf8().data(), iconUrl.utf8().data()); +} + +void FrameLoaderClientBlackBerry::saveViewStateToItem(HistoryItem* item) +{ + if (!isMainFrame()) + return; + + ASSERT(item); + HistoryItemViewState& viewState = item->viewState(); + if (viewState.shouldSaveViewState) { + viewState.orientation = m_webPagePrivate->mainFrame()->orientation(); + viewState.isZoomToFitScale = m_webPagePrivate->currentScale() == m_webPagePrivate->zoomToFitScale(); + viewState.scale = m_webPagePrivate->currentScale(); + viewState.shouldReflowBlock = m_webPagePrivate->m_shouldReflowBlock; + } +} + +void FrameLoaderClientBlackBerry::restoreViewState() +{ + if (!isMainFrame()) + return; + + HistoryItem* currentItem = m_frame->loader()->history()->currentItem(); + ASSERT(currentItem); + + if (!currentItem) + return; + + // WebPagePrivate is messing up FrameView::wasScrolledByUser() by sending + // scroll events that look like they were user generated all the time. + // + // Even if the user did not scroll, FrameView is gonna think they did. + // So we use our own bookkeeping code to keep track of whether we were + // actually scrolled by the user during load. + // + // If the user did scroll though, all are going to be in agreement about + // that, and the worst thing that could happen is that + // HistoryController::restoreScrollPositionAndViewState calls + // setScrollPosition with the the same point, which is a NOOP. + IntSize contentsSize = currentItem->contentsSize(); + IntPoint scrollPosition = currentItem->scrollPoint(); + if (m_webPagePrivate->m_userPerformedManualScroll) + scrollPosition = m_webPagePrivate->scrollPosition(); + + // We need to reset this variable after the view state has been restored. + m_webPagePrivate->m_didRestoreFromPageCache = false; + HistoryItemViewState& viewState = currentItem->viewState(); + + // Also, try to keep the users zoom if any. + double scale = viewState.scale; + bool shouldReflowBlock = viewState.shouldReflowBlock; + if (m_webPagePrivate->m_userPerformedManualZoom) { + scale = m_webPagePrivate->currentScale(); + shouldReflowBlock = m_webPagePrivate->m_shouldReflowBlock; + } + + bool scrollChanged = scrollPosition != m_webPagePrivate->scrollPosition(); + bool scaleChanged = scale != m_webPagePrivate->currentScale(); + bool reflowChanged = shouldReflowBlock != m_webPagePrivate->m_shouldReflowBlock; + bool orientationChanged = viewState.orientation % 180 != m_webPagePrivate->mainFrame()->orientation() % 180; + + if (!scrollChanged && !scaleChanged && !reflowChanged && !orientationChanged) + return; + + // When rotate happens, only zoom when previous page was zoomToFitScale, otherwise keep old scale. + if (orientationChanged && viewState.isZoomToFitScale) + scale = BlackBerry::Platform::Graphics::Screen::width() * scale / static_cast<double>(BlackBerry::Platform::Graphics::Screen::height()); + m_webPagePrivate->m_backingStore->d->suspendScreenAndBackingStoreUpdates(); // don't flash checkerboard for the setScrollPosition call + m_frame->view()->setContentsSizeFromHistory(contentsSize); + + // Here we need to set scroll position what we asked for. + // So we use ScrollView::setCanOverscroll(true). + bool oldCanOverscroll = m_frame->view()->canOverScroll(); + m_frame->view()->setCanOverscroll(true); + m_webPagePrivate->setScrollPosition(scrollPosition); + m_frame->view()->setCanOverscroll(oldCanOverscroll); + + m_webPagePrivate->m_shouldReflowBlock = viewState.shouldReflowBlock; + + // Will restore updates to backingstore guaranteed! + if (!m_webPagePrivate->zoomAboutPoint(scale, m_frame->view()->scrollPosition(), true /* enforceScaleClamping */, true /*forceRendering*/, true /*isRestoringZoomLevel*/)) { + // If we're already at that scale, then we should still force rendering since + // our scroll position changed. + m_webPagePrivate->m_backingStore->d->renderVisibleContents(); + + // We need to notify the client of the scroll position and content size change(s) above even if we didn't scale. + m_webPagePrivate->notifyTransformedContentsSizeChanged(); + m_webPagePrivate->notifyTransformedScrollChanged(); + } +} + +PolicyAction FrameLoaderClientBlackBerry::decidePolicyForExternalLoad(const ResourceRequest& request, bool isFragmentScroll) +{ + const KURL& url = request.url(); + String pattern = m_webPagePrivate->findPatternStringForUrl(url); + if (!pattern.isEmpty()) { + m_webPagePrivate->m_client->handleStringPattern(pattern.characters(), pattern.length()); + return PolicyIgnore; + } + + if (m_webPagePrivate->m_webSettings->areLinksHandledExternally() + && isMainFrame() + && !request.mustHandleInternally() + && !isFragmentScroll) { + BlackBerry::Platform::NetworkRequest platformRequest; + request.initializePlatformRequest(platformRequest); + m_webPagePrivate->m_client->handleExternalLink(platformRequest, request.anchorText().characters(), request.anchorText().length(), m_clientRedirectIsPending); + return PolicyIgnore; + } + + return PolicyUse; +} + +void FrameLoaderClientBlackBerry::willDeferLoading() +{ + m_deferredJobsTimer->stop(); + + if (!isMainFrame()) + return; + + m_webPagePrivate->willDeferLoading(); +} + +void FrameLoaderClientBlackBerry::didResumeLoading() +{ + if (!m_deferredManualScript.isNull()) + m_deferredJobsTimer->startOneShot(0); + + if (!isMainFrame()) + return; + + m_webPagePrivate->didResumeLoading(); +} + +void FrameLoaderClientBlackBerry::setDeferredManualScript(const KURL& script) +{ + ASSERT(!m_deferredJobsTimer->isActive()); + m_deferredManualScript = script; +} + +void FrameLoaderClientBlackBerry::deferredJobsTimerFired(Timer<FrameLoaderClientBlackBerry>*) +{ + ASSERT(!m_frame->page()->defersLoading()); + + if (!m_deferredManualScript.isNull()) { + // Executing the script will set deferred loading, which could trigger this timer again if a script is set. So clear the script first. + KURL script = m_deferredManualScript; + m_deferredManualScript = KURL(); + + m_frame->script()->executeIfJavaScriptURL(script); + } + + ASSERT(!m_frame->page()->defersLoading()); +} + +void FrameLoaderClientBlackBerry::readyToRender(bool pageIsVisuallyNonEmpty) +{ + // Only send the notification once. + if (!m_sentReadyToRender) { + m_webPagePrivate->m_client->notifyLoadReadyToRender(pageIsVisuallyNonEmpty); + m_sentReadyToRender = true; + } +} + +PassRefPtr<FrameNetworkingContext> FrameLoaderClientBlackBerry::createNetworkingContext() +{ + return FrameNetworkingContextBlackBerry::create(m_frame); +} + +void FrameLoaderClientBlackBerry::authenticationChallenge(const String& realm, String& username, String& password) +{ + WebString webPageUsername; + WebString webPagePassword; + + m_webPagePrivate->m_client->authenticationChallenge(realm.characters(), realm.length(), webPageUsername, webPagePassword); + + username = webPageUsername; + password = webPagePassword; +} + +void FrameLoaderClientBlackBerry::startDownload(const ResourceRequest& request, const String& /*suggestedName*/) +{ + // FIXME: use the suggestedName? + m_webPagePrivate->load(request.url().string().utf8().data(), 0, "GET", BlackBerry::Platform::NetworkRequest::UseProtocolCachePolicy, 0, 0, 0, 0, false, false, true, ""); +} + +void FrameLoaderClientBlackBerry::download(ResourceHandle* handle, const ResourceRequest&, const ResourceRequest&, const ResourceResponse& r) +{ + BlackBerry::Platform::FilterStream* stream = NetworkManager::instance()->streamForHandle(handle); + ASSERT(stream); + + m_webPagePrivate->m_client->downloadRequested(stream, r.suggestedFilename()); +} + +void FrameLoaderClientBlackBerry::dispatchDidReceiveIcon() +{ + String url = m_frame->document()->url().string(); + Image* img = iconDatabase().synchronousIconForPageURL(url, IntSize(10, 10)); + if (!img || !img->data()) + return; + + NativeImageSkia* bitmap = img->nativeImageForCurrentFrame(); + if (!bitmap) + return; + bitmap->lockPixels(); + String iconUrl = iconDatabase().synchronousIconURLForPageURL(url); + m_webPagePrivate->m_client->setFavicon(img->width(), img->height(), (unsigned char*)bitmap->getPixels(), iconUrl.utf8().data()); + bitmap->unlockPixels(); +} + +bool FrameLoaderClientBlackBerry::canCachePage() const +{ + // We won't cache pages containing video or audio. + ASSERT(m_frame->document()); + RefPtr<NodeList> nodeList = m_frame->document()->getElementsByTagName(HTMLNames::videoTag.localName()); + if (nodeList.get()->length() > 0) + return false; + nodeList = m_frame->document()->getElementsByTagName(HTMLNames::audioTag.localName()); + if (nodeList.get()->length() > 0) + return false; + + // The multipart of "multipart/x-mixed-replace" only supports image, correct? + // FIXME: Do we have a better place to handle this case? + nodeList = m_frame->document()->getElementsByTagName(HTMLNames::imgTag.localName()); + for (unsigned i = 0; i < nodeList.get()->length(); ++i) { + HTMLImageElement* node = static_cast<HTMLImageElement*>(nodeList.get()->item(i)); + CachedImage* cachedimage = node ? node->cachedImage() : 0; + if (cachedimage && cachedimage->response().isMultipartPayload()) + return false; + } + return true; +} + +void FrameLoaderClientBlackBerry::didSaveToPageCache() +{ + // When page goes into PageCache, clean up any possible + // document data cache we might have. + m_webPagePrivate->clearDocumentData(m_frame->document()); +} + +void FrameLoaderClientBlackBerry::provisionalLoadStarted() +{ + // We would like to hide the virtual keyboard before it navigates to another page + // so that the scroll offset without keyboard shown will be saved in the history item. + // Then when the user navigates back, it will scroll to the right position. + if (isMainFrame()) + m_webPagePrivate->showVirtualKeyboard(false); +} + +// We don't need to provide the error message string, that will be handled in BrowserErrorPage according to the error code. +ResourceError FrameLoaderClientBlackBerry::cannotShowURLError(const ResourceRequest& request) +{ + // FIXME: Why are we not passing the domain to the ResourceError? See PR #119789. + return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String()); +} + +void FrameLoaderClientBlackBerry::didRestoreFromPageCache() +{ + m_webPagePrivate->m_didRestoreFromPageCache = true; +} + +void FrameLoaderClientBlackBerry::dispatchWillUpdateApplicationCache(const ResourceRequest&) +{ + ASSERT(isMainFrame()); + if (!isMainFrame()) + return; + + m_webPagePrivate->m_client->notifyWillUpdateApplicationCache(); +} + +void FrameLoaderClientBlackBerry::dispatchDidLoadFromApplicationCache(const ResourceRequest&) +{ + ASSERT(isMainFrame()); + if (!isMainFrame()) + return; + + m_webPagePrivate->m_client->notifyDidLoadFromApplicationCache(); +} + +} // WebCore diff --git a/Source/WebKit/blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.h b/Source/WebKit/blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.h new file mode 100644 index 000000000..2983d01ee --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/FrameLoaderClientBlackBerry.h @@ -0,0 +1,235 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef FrameLoaderClientBlackBerry_h +#define FrameLoaderClientBlackBerry_h + +#include "DocumentLoader.h" +#include "Frame.h" +#include "FrameLoaderClient.h" +#include "NotImplemented.h" +#include "Widget.h" + +namespace BlackBerry { +namespace WebKit { +class WebPagePrivate; +} +} + +namespace WebCore { + +class FrameNetworkingContext; +class Geolocation; + +class FrameLoaderClientBlackBerry : public FrameLoaderClient { +public: + FrameLoaderClientBlackBerry(); + ~FrameLoaderClientBlackBerry(); + + void setFrame(Frame* frame, BlackBerry::WebKit::WebPagePrivate* webPagePrivate) { m_frame = frame; m_webPagePrivate = webPagePrivate; } + + int playerId() const; + bool cookiesEnabled() const; + + virtual void frameLoaderDestroyed(); + virtual bool hasWebView() const { return true; } + virtual void makeRepresentation(DocumentLoader*) { notImplemented(); } + virtual void forceLayout() { notImplemented(); } + virtual void forceLayoutForNonHTML() { notImplemented(); } + virtual void setCopiesOnScroll() { notImplemented(); } + virtual void detachedFromParent2(); + virtual void detachedFromParent3() { notImplemented(); } + virtual void assignIdentifierToInitialRequest(long unsigned int, DocumentLoader*, const ResourceRequest&) { notImplemented(); } + virtual void dispatchWillSendRequest(DocumentLoader*, long unsigned int, ResourceRequest&, const ResourceResponse&); + virtual bool shouldUseCredentialStorage(DocumentLoader*, long unsigned int) { notImplemented(); return false; } + virtual void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, long unsigned int, const AuthenticationChallenge&) { notImplemented(); } + virtual void dispatchDidCancelAuthenticationChallenge(DocumentLoader*, long unsigned int, const AuthenticationChallenge&) { notImplemented(); } + virtual void dispatchDidReceiveResponse(DocumentLoader*, long unsigned int, const ResourceResponse&); + virtual void dispatchDidReceiveContentLength(DocumentLoader*, long unsigned int, int) { notImplemented(); } + virtual void dispatchDidFinishLoading(DocumentLoader*, long unsigned int) { notImplemented(); } + virtual void dispatchDidFailLoading(DocumentLoader*, long unsigned int, const ResourceError&) { notImplemented(); } + virtual bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int) { notImplemented(); return false; } + virtual void dispatchDidHandleOnloadEvents(); + virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() { notImplemented(); } + virtual void dispatchDidCancelClientRedirect(); + virtual void dispatchWillPerformClientRedirect(const KURL&, double, double); + virtual void dispatchDidChangeLocationWithinPage(); + virtual void dispatchDidPushStateWithinPage(); + virtual void dispatchDidReplaceStateWithinPage(); + virtual void dispatchDidPopStateWithinPage(); + virtual void dispatchWillClose(); + virtual void dispatchDidReceiveIcon(); + virtual void dispatchDidStartProvisionalLoad(); + virtual void dispatchDidReceiveTitle(const StringWithDirection&); + virtual void setTitle(const StringWithDirection& title, const KURL&); + virtual void dispatchDidCommitLoad(); + virtual void dispatchDidFailProvisionalLoad(const ResourceError&); + virtual void dispatchDidFailLoad(const ResourceError&); + virtual void dispatchDidFinishDocumentLoad(); + virtual void dispatchDidFinishLoad(); + virtual void dispatchDidFirstLayout() { notImplemented(); } + virtual void dispatchDidFirstVisuallyNonEmptyLayout(); + virtual Frame* dispatchCreatePage(const NavigationAction&); + virtual void dispatchShow() { notImplemented(); } + + virtual void dispatchDecidePolicyForResponse(FramePolicyFunction, const ResourceResponse&, const ResourceRequest&); + virtual void dispatchDecidePolicyForNewWindowAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName); + virtual void dispatchDecidePolicyForNavigationAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>); + virtual void cancelPolicyCheck(); + virtual void dispatchUnableToImplementPolicy(const ResourceError&) { notImplemented(); } + virtual void dispatchWillSubmitForm(FramePolicyFunction, PassRefPtr<FormState>); + virtual void dispatchDidLoadMainResource(DocumentLoader*) { notImplemented(); } + virtual void revertToProvisionalState(DocumentLoader*) { notImplemented(); } + virtual void setMainDocumentError(DocumentLoader*, const ResourceError&); + virtual void postProgressStartedNotification(); + virtual void postProgressEstimateChangedNotification(); + virtual void postProgressFinishedNotification(); + virtual void setMainFrameDocumentReady(bool) { notImplemented(); } + virtual void startDownload(const ResourceRequest&, const String& suggestedName = String()); + virtual void willChangeTitle(DocumentLoader*) { notImplemented(); } + virtual void didChangeTitle(DocumentLoader*) { notImplemented(); } + virtual void committedLoad(DocumentLoader*, const char*, int); + virtual void finishedLoading(DocumentLoader*); + virtual void updateGlobalHistory() { notImplemented(); } + virtual void updateGlobalHistoryRedirectLinks() { notImplemented(); } + virtual bool shouldGoToHistoryItem(HistoryItem*) const; + virtual bool shouldStopLoadingForHistoryItem(HistoryItem*) const; + virtual void dispatchDidAddBackForwardItem(HistoryItem*) const; + virtual void dispatchDidRemoveBackForwardItem(HistoryItem*) const; + virtual void dispatchDidChangeBackForwardIndex() const; + virtual void dispatchWillUpdateApplicationCache(const ResourceRequest&); + virtual void dispatchDidLoadFromApplicationCache(const ResourceRequest&); + virtual void didDisplayInsecureContent() { notImplemented(); } + virtual void didRunInsecureContent(SecurityOrigin*, const KURL&) { notImplemented(); } + virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual ResourceError cancelledError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual ResourceError blockedError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual ResourceError cannotShowURLError(const ResourceRequest&); + virtual ResourceError interruptForPolicyChangeError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual ResourceError fileDoesNotExistError(const ResourceResponse&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual ResourceError pluginWillHandleLoadError(const ResourceResponse&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); } + virtual bool shouldFallBack(const ResourceError&) { notImplemented(); return false; } + virtual bool canHandleRequest(const ResourceRequest&) const; + virtual bool canShowMIMEType(const String&) const; + virtual bool canShowMIMETypeAsHTML(const String&) const; + virtual bool representationExistsForURLScheme(const String&) const { notImplemented(); return false; } + virtual String generatedMIMETypeForURLScheme(const String&) const { notImplemented(); return String(); } + virtual void frameLoadCompleted() { notImplemented(); } + virtual void saveViewStateToItem(HistoryItem*); + virtual void restoreViewState(); + virtual void provisionalLoadStarted(); + virtual void didFinishLoad() { notImplemented(); } + virtual void prepareForDataSourceReplacement() { notImplemented(); } + virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&); + virtual void setTitle(const String&, const KURL&) { notImplemented(); } + virtual String userAgent(const KURL&); + virtual void savePlatformDataToCachedFrame(CachedFrame*) { notImplemented(); } + virtual void transitionToCommittedFromCachedFrame(CachedFrame*) { notImplemented(); } + virtual void transitionToCommittedForNewPage(); + virtual bool canCachePage() const; + virtual void didSaveToPageCache(); + virtual void didRestoreFromPageCache(); + virtual void dispatchDidBecomeFrameset(bool) { } + virtual void download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&); + virtual PassRefPtr<Frame> createFrame(const KURL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int); + virtual void didTransferChildFrameToNewDocument(Page*); + virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool); + virtual void redirectDataToPlugin(Widget*); + virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL&, const Vector<String>&, const Vector<String>&) { notImplemented(); return 0; } + + virtual ObjectContentType objectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages); + virtual String overrideMediaType() const { notImplemented(); return String(); } + virtual void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*); + virtual void documentElementAvailable() { notImplemented(); } + virtual void didPerformFirstNavigation() const { notImplemented(); } + virtual void registerForIconNotification(bool) { notImplemented(); } + + virtual bool shouldLoadIconExternally() { return false; } + virtual void loadIconExternally(const String& originalPageUrl, const String& finalPageUrl, const String& iconUrl); + + virtual void didDetectXSS(const KURL&, bool) { } + virtual void transferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*); + virtual void didTransferChildFrameToNewDocument() { notImplemented(); }; + virtual void dispatchDidChangeIcons(IconType) { notImplemented(); }; + virtual void dispatchWillSendSubmitEvent(HTMLFormElement*) { notImplemented(); }; + + virtual void willDeferLoading(); + virtual void didResumeLoading(); + virtual void authenticationChallenge(const String& realm, String& username, String& password); + + virtual PassRefPtr<FrameNetworkingContext> createNetworkingContext(); + + // Schedule a script that was loaded manually by the user (eg. a + // bookmarklet) while page loading was deferred. + void setDeferredManualScript(const KURL&); + + void readyToRender(bool pageIsVisuallyNonEmpty); + + void doPendingFragmentScroll(); + + // Used to stop media files from loading because we don't need to have the entire file loaded by WebKit. + void setCancelLoadOnNextData() { m_cancelLoadOnNextData = true; } + bool shouldCancelLoadOnNextData() const { return m_cancelLoadOnNextData; } + + void suppressChildFrameCreation() { m_childFrameCreationSuppressed = true; } + +private: + void receivedData(const char*, int, const String&); + void didFinishOrFailLoading(const ResourceError&); + bool isMainFrame() const; + + void invalidateBackForwardList() const; + void notifyBackForwardListChanged() const; + + PolicyAction decidePolicyForExternalLoad(const ResourceRequest &, bool isFragmentScroll); + void delayPolicyCheckUntilFragmentExists(const String& fragment, FramePolicyFunction); + + void deferredJobsTimerFired(Timer<FrameLoaderClientBlackBerry>*); + + Frame* m_frame; + ResourceError m_loadError; + BlackBerry::WebKit::WebPagePrivate* m_webPagePrivate; + + Timer<FrameLoaderClientBlackBerry>* m_deferredJobsTimer; + KURL m_deferredManualScript; + Geolocation* m_geolocation; + bool m_sentReadyToRender; + + FramePolicyFunction m_pendingFragmentScrollPolicyFunction; + String m_pendingFragmentScroll; + + bool m_loadingErrorPage; + bool m_clientRedirectIsPending; + bool m_childFrameCreationSuppressed; + + // This set includes the original and final urls for server redirects. + HashSet<KURL> m_historyNavigationSourceURLs; + HashSet<KURL> m_redirectURLsToSkipDueToHistoryNavigation; + + // Plugin view to redirect data to. + PluginView* m_pluginView; + bool m_hasSentResponseToPlugin; + + // Used to stop media files from loading because we don't need to have the entire file loaded by WebKit. + bool m_cancelLoadOnNextData; +}; + +} // WebCore + +#endif // FrameLoaderClientBlackBerry_h diff --git a/Source/WebKit/blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.cpp b/Source/WebKit/blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.cpp new file mode 100644 index 000000000..ffe7e9383 --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.cpp @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/ + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" + +#if ENABLE(JAVASCRIPT_DEBUGGER) +#include "JavaScriptDebuggerBlackBerry.h" + +#include "JavaScriptCallFrame.h" +#include "PageScriptDebugServer.h" +#include "PlatformString.h" +#include "ScriptBreakpoint.h" +#include "SourceCode.h" +#include "WebPage_p.h" + +namespace WebCore { + +JavaScriptDebuggerBlackBerry::JavaScriptDebuggerBlackBerry(BlackBerry::WebKit::WebPagePrivate* webPagePrivate) + : m_webPagePrivate(webPagePrivate) + , m_debugServer(PageScriptDebugServer::shared()) +{ + start(); +} + +JavaScriptDebuggerBlackBerry::~JavaScriptDebuggerBlackBerry() +{ + stop(); +} + +void JavaScriptDebuggerBlackBerry::start() +{ + m_debugServer.addListener(this, m_webPagePrivate->m_page); +} + +void JavaScriptDebuggerBlackBerry::stop() +{ + m_debugServer.removeListener(this, m_webPagePrivate->m_page); +} + +void JavaScriptDebuggerBlackBerry::addBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength) +{ + if (!url || !urlLength) + return; + if (!m_currentCallFrame) + return; + + String sourceString(url, urlLength); + String conditionString(condition, conditionLength); + int actualLineNumber; + m_debugServer.setBreakpoint(sourceString, ScriptBreakpoint(lineNumber, 0, conditionString), &lineNumber, &actualLineNumber); +} + +void JavaScriptDebuggerBlackBerry::updateBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength) +{ + if (!url || !urlLength) + return; + if (!m_currentCallFrame) + return; + + String sourceString(url, urlLength); + String conditionString(condition, conditionLength); + int actualLineNumber; + m_debugServer.setBreakpoint(sourceString, ScriptBreakpoint(lineNumber, 0, conditionString), &lineNumber, &actualLineNumber); +} + + +void JavaScriptDebuggerBlackBerry::removeBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber) +{ + if (!url || !urlLength) + return; + if (!m_currentCallFrame) + return; + + String sourceString(url, urlLength); + sourceString += ":" + lineNumber; + m_debugServer.removeBreakpoint(sourceString); +} + + +bool JavaScriptDebuggerBlackBerry::pauseOnExceptions() +{ + return m_debugServer.pauseOnExceptionsState() == ScriptDebugServer::PauseOnAllExceptions; +} + +void JavaScriptDebuggerBlackBerry::setPauseOnExceptions(bool pause) +{ + m_debugServer.setPauseOnExceptionsState(pause ? ScriptDebugServer::PauseOnAllExceptions : ScriptDebugServer::DontPauseOnExceptions); +} + +void JavaScriptDebuggerBlackBerry::pauseInDebugger() +{ + m_debugServer.setPauseOnNextStatement(true); +} + +void JavaScriptDebuggerBlackBerry::resumeDebugger() +{ + m_debugServer.continueProgram(); +} + +void JavaScriptDebuggerBlackBerry::stepOverStatementInDebugger() +{ + m_debugServer.stepOverStatement(); +} + +void JavaScriptDebuggerBlackBerry::stepIntoStatementInDebugger() +{ + m_debugServer.stepIntoStatement(); +} + +void JavaScriptDebuggerBlackBerry::stepOutOfFunctionInDebugger() +{ + m_debugServer.stepOutOfFunction(); +} + +void JavaScriptDebuggerBlackBerry::didParseSource(const String& sourceID, const Script& script) +{ + m_webPagePrivate->m_client->javascriptSourceParsed(script.url.characters(), script.url.length(), script.source.characters(), script.source.length()); +} + +void JavaScriptDebuggerBlackBerry::failedToParseSource(const String& url, const String& data, int firstLine, int errorLine, const String& errorMessage) +{ + m_webPagePrivate->m_client->javascriptParsingFailed(url.impl()->characters(), url.length(), errorMessage.impl()->characters(), errorMessage.length(), errorLine); +} + +void JavaScriptDebuggerBlackBerry::didPause(ScriptState*, const ScriptValue& callFrames, const ScriptValue& exception) +{ + String stacks; + + m_currentCallFrame = m_debugServer.currentCallFrame(); + JavaScriptCallFrame* frame = m_currentCallFrame; + + while (frame && frame->isValid()) { + JSC::SourceProvider* provider = reinterpret_cast<JSC::SourceProvider*>(frame->sourceID()); + String url(provider->url().characters(), provider->url().length()); + if (url.length()) + stacks += url; + stacks += ": "; + + if (frame->type() == JSC::DebuggerCallFrame::FunctionType) { + String name = frame->functionName(); + if (name.length()) + stacks += name; + } + stacks += "(): "; + + String line = String::number(frame->line()); + stacks += line + "\n"; + + frame = frame->caller(); + } + + m_webPagePrivate->m_client->javascriptPaused(reinterpret_cast<const unsigned short*>(stacks.characters()), stacks.length()); +} + +void JavaScriptDebuggerBlackBerry::didContinue() +{ + m_currentCallFrame = 0; + m_webPagePrivate->m_client->javascriptContinued(); +} + +} // namespace WebCore + +#endif // ENABLE(JAVASCRIPT_DEBUGGER) diff --git a/Source/WebKit/blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.h b/Source/WebKit/blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.h new file mode 100644 index 000000000..2f511b2a3 --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/JavaScriptDebuggerBlackBerry.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/ + * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef JavaScriptDebuggerBlackBerry_h +#define JavaScriptDebuggerBlackBerry_h + +#if ENABLE(JAVASCRIPT_DEBUGGER) + +#include "ScriptDebugListener.h" + +namespace BlackBerry { +namespace WebKit { +class WebPagePrivate; +} +} + +namespace WebCore { + +class JavaScriptCallFrame; +class PageScriptDebugServer; + +class JavaScriptDebuggerBlackBerry : public ScriptDebugListener { +public: + JavaScriptDebuggerBlackBerry(BlackBerry::WebKit::WebPagePrivate*); + ~JavaScriptDebuggerBlackBerry(); + + void addBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength); + void updateBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber, const unsigned short* condition, unsigned conditionLength); + void removeBreakpoint(const unsigned short* url, unsigned urlLength, int lineNumber); + + bool pauseOnExceptions(); + void setPauseOnExceptions(bool); + + void pauseInDebugger(); + void resumeDebugger(); + + void stepOverStatementInDebugger(); + void stepIntoStatementInDebugger(); + void stepOutOfFunctionInDebugger(); + + // From ScriptDebugListener + virtual void didParseSource(const String& sourceID, const Script&); + virtual void failedToParseSource(const String& url, const String& data, int firstLine, int errorLine, const String& errorMessage); + virtual void didPause(ScriptState*, const ScriptValue& callFrames, const ScriptValue& exception); + virtual void didContinue(); + +protected: + void start(); + void stop(); + +private: + BlackBerry::WebKit::WebPagePrivate* m_webPagePrivate; + PageScriptDebugServer& m_debugServer; + + JavaScriptCallFrame* m_currentCallFrame; +}; + +} // WebCore + +#endif // ENABLE(JAVASCRIPT_DEBUGGER) +#endif // JavaScriptDebuggerBlackBerry_h diff --git a/Source/WebKit/blackberry/WebCoreSupport/inspectorBB.html b/Source/WebKit/blackberry/WebCoreSupport/inspectorBB.html new file mode 100644 index 000000000..5f692197f --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/inspectorBB.html @@ -0,0 +1,64 @@ +<!-- +Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. +Copyright (C) 2011, 2012 Research In Motion Ltd. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + its contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--> +<!DOCTYPE html> +<html> + <head> + <meta http-equiv="content-type" content="text/html; charset=utf-8"> + <link rel="stylesheet" type="text/css" href="audits.css"> + <link rel="stylesheet" type="text/css" href="dataGrid.css"> + <link rel="stylesheet" type="text/css" href="goToLineDialog.css"> + <link rel="stylesheet" type="text/css" href="heapProfiler.css"> + <link rel="stylesheet" type="text/css" href="inspector.css"> + <link rel="stylesheet" type="text/css" href="inspectorCommon.css"> + <link rel="stylesheet" type="text/css" href="inspectorSyntaxHighlight.css"> + <link rel="stylesheet" type="text/css" href="networkPanel.css"> + <link rel="stylesheet" type="text/css" href="helpScreen.css"> + <link rel="stylesheet" type="text/css" href="popover.css"> + <link rel="stylesheet" type="text/css" href="textViewer.css"> + <script type="text/javascript" src="javascript.js"></script> + </head> + <body class="detached"> + <div id="toolbar"> + <div class="toolbar-item close-left"><button id="close-button-left"></button></div> + <div id="toolbar-controls"> + <div class="toolbar-item"><button id="toolbar-dropdown-arrow" class="toolbar-label">»</button></div> + <div class="toolbar-item hidden" id="search-results-matches"></div> + <div class="toolbar-item toolbar-search-item"><input id="search" type="search" incremental results="0"><div id="search-toolbar-label" class="toolbar-label"></div></div> + <div class="toolbar-item close-right"><button id="close-button-right"></button></div> + </div> + </div> + <div id="main"> + <div id="main-panels" spellcheck="false"></div> + <div id="main-status-bar" class="status-bar"><div id="anchored-status-bar-items"><div id="counters"><div id="error-warning-count" class="hidden"></div></div></div></div> + </div> + <div id="drawer"> + <div id="console-view"><div id="console-messages" class="monospace"><div id="console-prompt" spellcheck="false"><br></div></div></div> + <div id="drawer-status-bar" class="status-bar"><div id="other-drawer-status-bar-items"><button id="clear-console-status-bar-item" class="status-bar-item clear-status-bar-item"><div class="glyph"></div><div class="glyph shadow"></div></button><select id="console-context" class="status-bar-item"></select><div id="console-filter" class="scope-bar status-bar-item"></div></div></div> + </div> +</body> +</html> diff --git a/Source/WebKit/blackberry/WebCoreSupport/inspectorBB.js b/Source/WebKit/blackberry/WebCoreSupport/inspectorBB.js new file mode 100644 index 000000000..3017e0a58 --- /dev/null +++ b/Source/WebKit/blackberry/WebCoreSupport/inspectorBB.js @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +var context = {}; +(function () { + Preferences.ignoreWhitespace = false; + Preferences.samplingCPUProfiler = true; + Preferences.debuggerAlwaysEnabled = true; + Preferences.profilerAlwaysEnabled = true; + Preferences.canEditScriptSource = false; + Preferences.onlineDetectionEnabled = false; + Preferences.nativeInstrumentationEnabled = true; + // FIXME: Turn this to whatever the value of --enable-file-system for chrome. + Preferences.fileSystemEnabled = false; + Preferences.canClearCacheAndCookies = true; + Preferences.showCookiesTab = true; +})(); +InspectorFrontendHost.copyText = function(tmp) { + var encoded = encodeURI(tmp); + var text = 'data:text/plain;charset=utf-8,' + encoded; + window.open(text, "_blank"); +} diff --git a/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.cpp b/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.cpp new file mode 100644 index 000000000..c7de7716c --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.cpp @@ -0,0 +1,409 @@ +/* + * Copyright (C) 2009, 2010, 2011 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "BackingStoreClient.h" + +#include "BackingStore.h" +#include "BackingStore_p.h" +#include "FloatPoint.h" +#include "FocusController.h" +#include "Frame.h" +#include "FrameView.h" +#include "HTMLFrameOwnerElement.h" +#include "Page.h" +#include "RenderBox.h" +#include "WebPage_p.h" + +// FIXME: Leaving the below lines commented out as a reference for us to soon be sure if we need these +// methods and class variables be moved from WebPage to BackingStoreClient. +// Notification methods that deliver changes to the real geometry of the device as specified above. +// void notifyTransformChanged(); +// void notifyTransformedContentsSizeChanged(); +// void notifyTransformedScrollChanged(); +// m_overflowExceedsContentsSize = true; +// haspendingscrollevent + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { + +static inline IntSize pointToSize(const IntPoint& point) +{ + return IntSize(point.x(), point.y()); +} + +BackingStoreClient* BackingStoreClient::create(Frame* frame, Frame* parentFrame, WebPage* parentPage) +{ + ASSERT(parentPage); + ASSERT(frame->view()); + + // FIXME: We do not support inner frames for now. + if (parentFrame) + return 0; + + BackingStoreClient* parentBackingStoreClient + = parentFrame + ? parentPage->d->backingStoreClientForFrame(parentFrame) + : 0; + + // If this frame has a parent with no backingstore then just stop since + // our frame heirarchy is done. + if (parentFrame && !parentBackingStoreClient) + return 0; + + BackingStoreClient* it = new BackingStoreClient(frame, parentFrame, parentPage); + ASSERT(it); + + // Frame -> BackingStoreClient mapping is controlled by the Page. + parentPage->d->addBackingStoreClientForFrame(frame, it); + + // Add the backing store client to the child list of its parent. + if (parentBackingStoreClient) + parentBackingStoreClient->addChild(it); + + return it; +} + +BackingStoreClient::BackingStoreClient(Frame* frame, Frame* parentFrame, WebPage* parentPage) + : m_frame(frame) + , m_webPage(parentPage) + , m_backingStore(0) + , m_parent(0) + , m_isClientGeneratedScroll(false) + , m_isScrollNotificationSuppressed(false) +{ + UNUSED_PARAM(parentFrame); + m_backingStore = new BackingStore(m_webPage, this); +} + +BackingStoreClient::~BackingStoreClient() +{ + m_webPage->d->removeBackingStoreClientForFrame(m_frame); + + delete m_backingStore; + m_backingStore = 0; + m_frame = 0; +} + +void BackingStoreClient::addChild(BackingStoreClient* child) +{ + ASSERT(child); + child->m_parent = this; +} + +WTF::Vector <BackingStoreClient*> BackingStoreClient::children() const +{ + WTF::Vector<BackingStoreClient*> children; + for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) { + BlackBerry::WebKit::BackingStoreClient* client = + m_webPage->d->backingStoreClientForFrame(child); + + if (client) + children.append(client); + } + + return children; +} + +IntRect BackingStoreClient::absoluteRect() const +{ + IntRect rect = IntRect(IntPoint::zero(), viewportSize()); + + if (!isMainFrame()) { + // It is possible that the owner HTML element has been removed at this point, + // especially when the frame is loading a JavaScript URL. + if (Element* elt = m_frame->ownerElement()) { + if (RenderBox* obj = elt->renderBox()) + rect.move(obj->borderLeft() + obj->paddingLeft(), obj->borderTop() + obj->paddingTop()); + } + } + + Frame* frame = m_frame; + while (frame) { + if (Element* element = static_cast<Element*>(frame->ownerElement())) { + do { + rect.move(element->offsetLeft(), element->offsetTop()); + } while ((element = element->offsetParent())); + } + + if ((frame = frame->tree()->parent())) + rect.move((-frame->view()->scrollOffset())); + } + + return rect; +} + +IntRect BackingStoreClient::transformedAbsoluteRect() const +{ + return m_webPage->d->mapToTransformed(absoluteRect()); +} + +IntPoint BackingStoreClient::absoluteLocation() const +{ + return absoluteRect().location(); +} + +IntPoint BackingStoreClient::transformedAbsoluteLocation() const +{ + return m_webPage->d->mapToTransformed(transformedAbsoluteRect()).location(); +} + +IntPoint BackingStoreClient::scrollPosition() const +{ + ASSERT(m_frame); + return m_frame->view()->scrollPosition() - pointToSize(m_frame->view()->minimumScrollPosition()); +} + +IntPoint BackingStoreClient::transformedScrollPosition() const +{ + return m_webPage->d->mapToTransformed(scrollPosition()); +} + +void BackingStoreClient::setScrollPosition(const IntPoint& pos) +{ + ASSERT(m_frame->view()); + if (pos == scrollPosition()) + return; + + // We set a flag here to note that this scroll operation was originated + // within the BlackBerry-specific layer of WebKit and not by WebCore. + // This flag is checked in checkOriginOfCurrentScrollOperation() to decide + // whether to notify the client of the current scroll operation. This is + // why it is important that all scroll operations that originate within + // BlackBerry-specific code are encapsulated here and that callers of this + // method also directly or indirectly call notifyTransformedScrollChanged(). + m_isScrollNotificationSuppressed = true; + m_frame->view()->setScrollPosition(pos + pointToSize(m_frame->view()->minimumScrollPosition())); + m_isScrollNotificationSuppressed = false; +} + +IntPoint BackingStoreClient::maximumScrollPosition() const +{ + ASSERT(m_frame->view()); + return m_frame->view()->maximumScrollPosition() - pointToSize(m_frame->view()->minimumScrollPosition()); +} + +IntPoint BackingStoreClient::transformedMaximumScrollPosition() const +{ + return m_webPage->d->mapToTransformed(maximumScrollPosition()); +} + +IntSize BackingStoreClient::actualVisibleSize() const +{ + return m_webPage->d->mapFromTransformed(transformedActualVisibleSize()); +} + +IntSize BackingStoreClient::transformedActualVisibleSize() const +{ + if (isMainFrame()) + return m_webPage->d->transformedActualVisibleSize(); + + return transformedViewportSize(); +} + +IntSize BackingStoreClient::viewportSize() const +{ + ASSERT(m_frame->view()); + if (isMainFrame()) + return m_webPage->d->viewportSize(); + + return m_frame->view()->visibleContentRect().size(); +} + +IntSize BackingStoreClient::transformedViewportSize() const +{ + if (isMainFrame()) + return m_webPage->d->transformedViewportSize(); + + ASSERT(m_frame->view()); + const IntSize untransformedViewportSize = m_frame->view()->visibleContentRect().size(); + const FloatPoint transformedBottomRight = m_webPage->d->m_transformationMatrix->mapPoint( + FloatPoint(untransformedViewportSize.width(), untransformedViewportSize.height())); + return IntSize(floorf(transformedBottomRight.x()), floorf(transformedBottomRight.y())); +} + +IntRect BackingStoreClient::visibleContentsRect() const +{ + ASSERT(m_frame->view()); + IntRect visibleContentRect = m_frame->view()->visibleContentRect(); + if (isMainFrame()) + return visibleContentRect; + + IntPoint offset = absoluteLocation(); + visibleContentRect.move(offset.x(), offset.y()); + if (m_parent) + visibleContentRect.intersect(m_parent->visibleContentsRect()); + + return visibleContentRect; +} + +IntRect BackingStoreClient::transformedVisibleContentsRect() const +{ + // Usually this would be mapToTransformed(visibleContentsRect()), but + // that results in rounding errors because we already set the WebCore + // viewport size from our original transformedViewportSize(). + // Instead, we only transform the scroll position and take the + // viewport size as it is, which ensures that e.g. blitting operations + // always cover the whole widget/screen. + IntRect visibleContentsRect = IntRect(transformedScrollPosition(), transformedViewportSize()); + if (isMainFrame()) + return visibleContentsRect; + + IntPoint offset = transformedAbsoluteLocation(); + visibleContentsRect.move(offset.x(), offset.y()); + return visibleContentsRect; +} + +IntSize BackingStoreClient::contentsSize() const +{ + ASSERT(m_frame->view()); + return m_frame->view()->contentsSize(); +} + +IntSize BackingStoreClient::transformedContentsSize() const +{ + // mapToTransformed() functions use this method to crop their results, + // so we can't make use of them here. While we want rounding inside page + // boundaries to extend rectangles and round points, we need to crop the + // contents size to the floored values so that we don't try to display + // or report points that are not fully covered by the actual float-point + // contents rectangle. + const IntSize untransformedContentsSize = contentsSize(); + const FloatPoint transformedBottomRight = m_webPage->d->m_transformationMatrix->mapPoint( + FloatPoint(untransformedContentsSize.width(), untransformedContentsSize.height())); + return IntSize(floorf(transformedBottomRight.x()), floorf(transformedBottomRight.y())); +} + +void BackingStoreClient::clipToTransformedContentsRect(IntRect& rect) const +{ + // FIXME: Needs to proper translate coordinates here? + rect.intersect(IntRect(IntPoint::zero(), transformedContentsSize())); +} + +IntPoint BackingStoreClient::mapFromContentsToViewport(const IntPoint& point) const +{ + const IntPoint scrollPosition = this->scrollPosition(); + return IntPoint(point.x() - scrollPosition.x(), point.y() - scrollPosition.y()); +} + +IntPoint BackingStoreClient::mapFromViewportToContents(const IntPoint& point) const +{ + const IntPoint scrollPosition = this->scrollPosition(); + return IntPoint(point.x() + scrollPosition.x(), point.y() + scrollPosition.y()); +} + +IntRect BackingStoreClient::mapFromContentsToViewport(const IntRect& rect) const +{ + return IntRect(mapFromContentsToViewport(rect.location()), rect.size()); +} + +IntRect BackingStoreClient::mapFromViewportToContents(const IntRect& rect) const +{ + return IntRect(mapFromViewportToContents(rect.location()), rect.size()); +} + +IntPoint BackingStoreClient::mapFromTransformedContentsToTransformedViewport(const IntPoint& point) const +{ + const IntPoint scrollPosition = transformedScrollPosition(); + return IntPoint(point.x() - scrollPosition.x(), point.y() - scrollPosition.y()); +} + +IntPoint BackingStoreClient::mapFromTransformedViewportToTransformedContents(const IntPoint& point) const +{ + const IntPoint scrollPosition = transformedScrollPosition(); + return IntPoint(point.x() + scrollPosition.x(), point.y() + scrollPosition.y()); +} + +IntRect BackingStoreClient::mapFromTransformedContentsToTransformedViewport(const IntRect& rect) const +{ + return IntRect(mapFromTransformedContentsToTransformedViewport(rect.location()), rect.size()); +} + +IntRect BackingStoreClient::mapFromTransformedViewportToTransformedContents(const IntRect& rect) const +{ + return IntRect(mapFromTransformedViewportToTransformedContents(rect.location()), rect.size()); +} + +WebPagePrivate::LoadState BackingStoreClient::loadState() const +{ + // FIXME: Does it need to call WebPage's? + return m_webPage->d->loadState(); +} + +bool BackingStoreClient::isLoading() const +{ + // FIXME: Does it need to call WebPage's? + return m_webPage->d->isLoading(); +} + +bool BackingStoreClient::isFocused() const +{ + return m_frame && m_frame->page() && m_frame->page()->focusController() + && m_frame->page()->focusController()->focusedFrame() == m_frame; +} + +bool BackingStoreClient::scrollsHorizontally() const +{ + return transformedActualVisibleSize().width() < transformedContentsSize().width(); +} + +bool BackingStoreClient::scrollsVertically() const +{ + return transformedActualVisibleSize().height() < transformedContentsSize().height(); +} + +bool BackingStoreClient::isClientGeneratedScroll() const +{ + return m_isClientGeneratedScroll; +} + +void BackingStoreClient::setIsClientGeneratedScroll(bool flag) +{ + m_isClientGeneratedScroll = flag; +} + +bool BackingStoreClient::isScrollNotificationSuppressed() const +{ + return m_isScrollNotificationSuppressed; +} + +void BackingStoreClient::setIsScrollNotificationSuppressed(bool flag) +{ + m_isScrollNotificationSuppressed = flag; +} + +void BackingStoreClient::checkOriginOfCurrentScrollOperation() +{ + // This is called via ChromeClientBlackBerry::scroll in order to check the origin + // of the current scroll operation to decide whether to notify the client. + // If the current scroll operation was initiated internally by WebCore itself + // either via JavaScript, back/forward or otherwise then we need to go ahead + // and notify the client of this change. + if (isScrollNotificationSuppressed()) + return; + + if (isMainFrame()) + m_webPage->d->notifyTransformedScrollChanged(); + else + m_backingStore->d->scrollChanged(transformedScrollPosition()); +} + +} +} diff --git a/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.h b/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.h new file mode 100644 index 000000000..42b572104 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.h @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2009, 2010, 2011 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef BackingStoreClient_h +#define BackingStoreClient_h + +#include "WebPage_p.h" +#include <wtf/Vector.h> + +namespace WebCore { +class FloatPoint; +class Frame; +class IntPoint; +class IntSize; +class IntRect; +} + +namespace BlackBerry { +namespace WebKit { + +class BackingStore; +class WebPagePrivate; + +class BackingStoreClient { +public: + static BackingStoreClient* create(WebCore::Frame*, WebCore::Frame* parentFrame, WebPage* parentPage); + ~BackingStoreClient(); + + BackingStore* backingStore() const { return m_backingStore; } + WebCore::Frame* frame() const { return m_frame; } + bool isMainFrame() const { return m_frame == m_webPage->d->m_mainFrame; } + + void addChild(BackingStoreClient* child); + WTF::Vector <BackingStoreClient*> children() const; + BackingStoreClient* parent() const { return m_parent; } + + WebCore::IntPoint absoluteLocation() const; + WebCore::IntPoint transformedAbsoluteLocation() const; + WebCore::IntRect absoluteRect() const; + WebCore::IntRect transformedAbsoluteRect() const; + + // scroll position returned is in transformed coordinates + WebCore::IntPoint scrollPosition() const; + WebCore::IntPoint maximumScrollPosition() const; + // scroll position provided should be in transformed coordinates + void setScrollPosition(const WebCore::IntPoint&); + + WebCore::IntPoint transformedScrollPosition() const; + WebCore::IntPoint transformedMaximumScrollPosition() const; + + WebCore::IntSize actualVisibleSize() const; + WebCore::IntSize transformedActualVisibleSize() const; + + WebCore::IntSize viewportSize() const; + WebCore::IntSize transformedViewportSize() const; + + WebCore::IntRect visibleContentsRect() const; + WebCore::IntRect transformedVisibleContentsRect() const; + + WebCore::IntSize contentsSize() const; + WebCore::IntSize transformedContentsSize() const; + + /* Generic conversions of points, rects, relative to and from contents and viewport*/ + WebCore::IntPoint mapFromContentsToViewport(const WebCore::IntPoint&) const; + WebCore::IntPoint mapFromViewportToContents(const WebCore::IntPoint&) const; + WebCore::IntRect mapFromContentsToViewport(const WebCore::IntRect&) const; + WebCore::IntRect mapFromViewportToContents(const WebCore::IntRect&) const; + + /* Generic conversions of points, rects, relative to and from transformed contents and transformed viewport*/ + WebCore::IntPoint mapFromTransformedContentsToTransformedViewport(const WebCore::IntPoint&) const; + WebCore::IntPoint mapFromTransformedViewportToTransformedContents(const WebCore::IntPoint&) const; + WebCore::IntRect mapFromTransformedContentsToTransformedViewport(const WebCore::IntRect&) const; + WebCore::IntRect mapFromTransformedViewportToTransformedContents(const WebCore::IntRect&) const; + + void clipToTransformedContentsRect(WebCore::IntRect&) const; + + bool isLoading() const; + WebPagePrivate::LoadState loadState() const; + + bool isFocused() const; + + bool scrollsHorizontally() const; + bool scrollsVertically() const; + + bool isClientGeneratedScroll() const; + void setIsClientGeneratedScroll(bool); + + bool isScrollNotificationSuppressed() const; + void setIsScrollNotificationSuppressed(bool); + + /* Called from within WebKit via ChromeClientBlackBerry */ + void checkOriginOfCurrentScrollOperation(); + +private: + BackingStoreClient(WebCore::Frame*, WebCore::Frame* parentFrame, WebPage* parentPage); + + WebCore::Frame* m_frame; + WebPage* m_webPage; + BackingStore* m_backingStore; + BackingStoreClient* m_parent; + bool m_isClientGeneratedScroll; + bool m_isScrollNotificationSuppressed; +}; + +} +} + +#endif // BackingStoreClient_h diff --git a/Source/WebKit/blackberry/WebKitSupport/BackingStoreCompositingSurface.cpp b/Source/WebKit/blackberry/WebKitSupport/BackingStoreCompositingSurface.cpp new file mode 100644 index 000000000..43e075a39 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/BackingStoreCompositingSurface.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "BackingStoreCompositingSurface.h" + +#include "GraphicsContext.h" +#include "SurfacePool.h" + +#if USE(ACCELERATED_COMPOSITING) + +#include <BlackBerryPlatformGraphics.h> + +namespace BlackBerry { +namespace WebKit { + +CompositingSurfaceBuffer::CompositingSurfaceBuffer(const Platform::IntSize& size) + : m_size(size) + , m_buffer(0) +{ +} + +CompositingSurfaceBuffer::~CompositingSurfaceBuffer() +{ + destroyBuffer(m_buffer); +} + +Platform::IntSize CompositingSurfaceBuffer::surfaceSize() const +{ + return m_size; +} + +Platform::Graphics::Buffer* CompositingSurfaceBuffer::nativeBuffer() const +{ + if (!m_buffer) { + m_buffer = createBuffer(m_size, + Platform::Graphics::TileBuffer, + Platform::Graphics::GLES2); + } + return m_buffer; +} + +BackingStoreCompositingSurface::BackingStoreCompositingSurface(const Platform::IntSize& size, bool doubleBuffered) + : m_isDoubleBuffered(doubleBuffered) + , m_needsSync(true) +{ + m_frontBuffer = new CompositingSurfaceBuffer(size); + m_backBuffer = !doubleBuffered ? 0 : new CompositingSurfaceBuffer(size); +} + +BackingStoreCompositingSurface::~BackingStoreCompositingSurface() +{ + delete m_frontBuffer; + m_frontBuffer = 0; + + delete m_backBuffer; + m_backBuffer = 0; +} + +CompositingSurfaceBuffer* BackingStoreCompositingSurface::frontBuffer() const +{ + ASSERT(m_frontBuffer); + return m_frontBuffer; +} + +CompositingSurfaceBuffer* BackingStoreCompositingSurface::backBuffer() const +{ + if (!m_isDoubleBuffered) + return frontBuffer(); + + ASSERT(m_backBuffer); + return m_backBuffer; +} + +void BackingStoreCompositingSurface::swapBuffers() +{ + if (!m_isDoubleBuffered) + return; + + // Store temps. + unsigned front = reinterpret_cast<unsigned>(frontBuffer()); + unsigned back = reinterpret_cast<unsigned>(backBuffer()); + + // Atomic change. + _smp_xchg(reinterpret_cast<unsigned*>(&m_frontBuffer), back); + _smp_xchg(reinterpret_cast<unsigned*>(&m_backBuffer), front); +} + +} // namespace WebKit +} // namespace BlackBerry +#endif // USE(ACCELERATED_COMPOSITING) diff --git a/Source/WebKit/blackberry/WebKitSupport/BackingStoreCompositingSurface.h b/Source/WebKit/blackberry/WebKitSupport/BackingStoreCompositingSurface.h new file mode 100644 index 000000000..d4ec45c52 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/BackingStoreCompositingSurface.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef BackingStoreCompositingSurface_h +#define BackingStoreCompositingSurface_h + +#if USE(ACCELERATED_COMPOSITING) + +#include <BlackBerryPlatformIntRectRegion.h> +#include <wtf/RefPtr.h> +#include <wtf/ThreadSafeRefCounted.h> + +namespace BlackBerry { + +namespace Platform { +namespace Graphics { +struct Buffer; +} +} + +namespace WebKit { +class CompositingSurfaceBuffer { +public: + CompositingSurfaceBuffer(const Platform::IntSize&); + ~CompositingSurfaceBuffer(); + Platform::IntSize surfaceSize() const; + + Platform::Graphics::Buffer* nativeBuffer() const; + +private: + Platform::IntSize m_size; + mutable Platform::Graphics::Buffer* m_buffer; +}; + + +class BackingStoreCompositingSurface : public ThreadSafeRefCounted<BackingStoreCompositingSurface> { +public: + static PassRefPtr<BackingStoreCompositingSurface> create(const Platform::IntSize& size, bool doubleBuffered) + { + return adoptRef(new BackingStoreCompositingSurface(size, doubleBuffered)); + } + + ~BackingStoreCompositingSurface(); + + CompositingSurfaceBuffer* frontBuffer() const; + CompositingSurfaceBuffer* backBuffer() const; + bool isDoubleBuffered() const { return m_isDoubleBuffered; } + void swapBuffers(); + + bool needsSync() const { return m_needsSync; } + void setNeedsSync(bool needsSync) { m_needsSync = needsSync; } + +private: + BackingStoreCompositingSurface(const Platform::IntSize&, bool doubleBuffered); + + mutable CompositingSurfaceBuffer* m_frontBuffer; + mutable CompositingSurfaceBuffer* m_backBuffer; + bool m_isDoubleBuffered; + bool m_needsSync; +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif // BackingStoreCompositingSurface_h diff --git a/Source/WebKit/blackberry/WebKitSupport/BackingStoreTile.cpp b/Source/WebKit/blackberry/WebKitSupport/BackingStoreTile.cpp new file mode 100644 index 000000000..a02f93a1c --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/BackingStoreTile.cpp @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "BackingStoreTile.h" + +#include "GraphicsContext.h" +#include "SurfacePool.h" + +#include <BlackBerryPlatformGraphics.h> + +namespace BlackBerry { +namespace WebKit { + +TileBuffer::TileBuffer(const Platform::IntSize& size) + : m_size(size) + , m_buffer(0) + , m_blitGeneration(0) +{ +} + +TileBuffer::~TileBuffer() +{ + destroyBuffer(m_buffer); +} + +Platform::IntSize TileBuffer::size() const +{ + return m_size; +} + +Platform::IntRect TileBuffer::rect() const +{ + return Platform::IntRect(Platform::IntPoint::zero(), m_size); +} + +bool TileBuffer::isRendered() const +{ + return isRendered(rect()); +} + +bool TileBuffer::isRendered(const Platform::IntRectRegion& contents) const +{ + return Platform::IntRectRegion::subtractRegions(contents, m_renderedRegion).isEmpty(); +} + +void TileBuffer::clearRenderedRegion(const Platform::IntRectRegion& region) +{ + m_renderedRegion = Platform::IntRectRegion::subtractRegions(m_renderedRegion, region); +} + +void TileBuffer::clearRenderedRegion() +{ + m_renderedRegion = Platform::IntRectRegion(); +} + +void TileBuffer::addRenderedRegion(const Platform::IntRectRegion& region) +{ + m_renderedRegion = Platform::IntRectRegion::unionRegions(region, m_renderedRegion); +} + +Platform::IntRectRegion TileBuffer::renderedRegion() const +{ + return m_renderedRegion; +} + +Platform::IntRectRegion TileBuffer::notRenderedRegion() const +{ + return Platform::IntRectRegion::subtractRegions(rect(), renderedRegion()); +} + +Platform::Graphics::Buffer* TileBuffer::nativeBuffer() const +{ + if (!m_buffer) + m_buffer = createBuffer(m_size, Platform::Graphics::TileBuffer, SurfacePool::globalSurfacePool()->sharedPixmapGroup()); + + return m_buffer; +} + + +BackingStoreTile::BackingStoreTile(const Platform::IntSize& size, BufferingMode mode) + : m_bufferingMode(mode) + , m_committed(false) + , m_backgroundPainted(false) + , m_horizontalShift(0) + , m_verticalShift(0) +{ + m_frontBuffer = new TileBuffer(size); +} + +BackingStoreTile::~BackingStoreTile() +{ + delete m_frontBuffer; + m_frontBuffer = 0; +} + +Platform::IntSize BackingStoreTile::size() const +{ + return frontBuffer()->size(); +} + +Platform::IntRect BackingStoreTile::rect() const +{ + return frontBuffer()->rect(); +} + +TileBuffer* BackingStoreTile::frontBuffer() const +{ + ASSERT(m_frontBuffer); + return m_frontBuffer; +} + +TileBuffer* BackingStoreTile::backBuffer() const +{ + if (m_bufferingMode == SingleBuffered) + return frontBuffer(); + + return SurfacePool::globalSurfacePool()->backBuffer(); +} + +void BackingStoreTile::swapBuffers() +{ + if (m_bufferingMode == SingleBuffered) + return; + + // Store temps. + unsigned front = reinterpret_cast<unsigned>(frontBuffer()); + unsigned back = reinterpret_cast<unsigned>(backBuffer()); + + // Atomic change. + _smp_xchg(reinterpret_cast<unsigned*>(&m_frontBuffer), back); + _smp_xchg(reinterpret_cast<unsigned*>(&SurfacePool::globalSurfacePool()->m_backBuffer), front); +} + +void BackingStoreTile::reset() +{ + setCommitted(false); + frontBuffer()->clearRenderedRegion(); + backBuffer()->clearRenderedRegion(); + clearShift(); +} + +void BackingStoreTile::paintBackground() +{ + m_backgroundPainted = true; + + clearBuffer(backBuffer()->nativeBuffer(), 0, 0, 0, 0); +} + +} +} diff --git a/Source/WebKit/blackberry/WebKitSupport/BackingStoreTile.h b/Source/WebKit/blackberry/WebKitSupport/BackingStoreTile.h new file mode 100644 index 000000000..7a0a42f5d --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/BackingStoreTile.h @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef BackingStoreTile_h +#define BackingStoreTile_h + +#include "BlackBerryPlatformIntRectRegion.h" +#include "BlackBerryPlatformPrimitives.h" + +namespace BlackBerry { +namespace Platform { +namespace Graphics { +struct Buffer; +} +} + +namespace WebKit { +class TileBuffer { + public: + TileBuffer(const Platform::IntSize&); + ~TileBuffer(); + Platform::IntSize size() const; + Platform::IntRect rect() const; + + bool isRendered() const; + bool isRendered(const Platform::IntRectRegion& contents) const; + void clearRenderedRegion(); + void clearRenderedRegion(const Platform::IntRectRegion&); + void addRenderedRegion(const Platform::IntRectRegion&); + Platform::IntRectRegion renderedRegion() const; + Platform::IntRectRegion notRenderedRegion() const; + + Platform::Graphics::Buffer* nativeBuffer() const; + + void setBlitGeneration(int g) const { m_blitGeneration = g; } + int blitGeneration() const { return m_blitGeneration; } + + private: + Platform::IntSize m_size; + Platform::IntRectRegion m_renderedRegion; + mutable Platform::Graphics::Buffer* m_buffer; + mutable int m_blitGeneration; +}; + + +class BackingStoreTile { +public: + enum BufferingMode { SingleBuffered, DoubleBuffered }; + + static BackingStoreTile* create(const Platform::IntSize& size, BufferingMode mode) + { + return new BackingStoreTile(size, mode); + } + + ~BackingStoreTile(); + + Platform::IntSize size() const; + Platform::IntRect rect() const; + + TileBuffer* frontBuffer() const; + TileBuffer* backBuffer() const; + bool isDoubleBuffered() const { return m_bufferingMode == DoubleBuffered; } + + void reset(); + bool backgroundPainted() const { return m_backgroundPainted; } + void paintBackground(); + + bool isCommitted() const { return m_committed; } + void setCommitted(bool committed) { m_committed = committed; } + + void clearShift() { m_horizontalShift = 0; m_verticalShift = 0; } + int horizontalShift() const { return m_horizontalShift; } + void setHorizontalShift(int shift) { m_horizontalShift = shift; } + int verticalShift() const { return m_verticalShift; } + void setVerticalShift(int shift) { m_verticalShift = shift; } + + void swapBuffers(); + +private: + BackingStoreTile(const Platform::IntSize&, BufferingMode); + + mutable TileBuffer* m_frontBuffer; + BufferingMode m_bufferingMode; + bool m_checkered; + bool m_committed; + bool m_backgroundPainted; + int m_horizontalShift; + int m_verticalShift; +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // BackingStoreTile_h diff --git a/Source/WebKit/blackberry/WebKitSupport/DOMSupport.cpp b/Source/WebKit/blackberry/WebKitSupport/DOMSupport.cpp new file mode 100644 index 000000000..9dd5d2117 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/DOMSupport.cpp @@ -0,0 +1,404 @@ +/* + * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "DOMSupport.h" + +#include "FloatQuad.h" +#include "Frame.h" +#include "FrameView.h" +#include "HTMLFormElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "HTMLTextAreaElement.h" +#include "Node.h" +#include "Range.h" +#include "RenderObject.h" +#include "RenderText.h" +#include "RenderTextControl.h" +#include "TextIterator.h" +#include "VisibleSelection.h" +#include "WTFString.h" + +#include "htmlediting.h" +#include "visible_units.h" + +#include <limits> + +using WTF::Vector; + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { +namespace DOMSupport { + +void visibleTextQuads(const Range& range, Vector<FloatQuad>& quads, bool useSelectionHeight) +{ + // Range::textQuads includes hidden text, which we don't want. + // To work around this, this is a copy of it which skips hidden elements. + Node* startContainer = range.startContainer(); + Node* endContainer = range.endContainer(); + + if (!startContainer || !endContainer) + return; + + Node* stopNode = range.pastLastNode(); + for (Node* node = range.firstNode(); node != stopNode; node = node->traverseNextNode()) { + RenderObject* r = node->renderer(); + if (!r || !r->isText()) + continue; + + if (r->style()->visibility() != VISIBLE) + continue; + + RenderText* renderText = toRenderText(r); + int startOffset = node == startContainer ? range.startOffset() : 0; + int endOffset = node == endContainer ? range.endOffset() : std::numeric_limits<int>::max(); + renderText->absoluteQuadsForRange(quads, startOffset, endOffset, useSelectionHeight); + } +} + +bool isTextInputElement(Element* element) +{ + return element->isTextFormControl() + || element->hasTagName(HTMLNames::textareaTag) + || element->isContentEditable(); +} + +bool isPasswordElement(const Element* element) +{ + return element && element->hasTagName(HTMLNames::inputTag) + && static_cast<const HTMLInputElement*>(element)->isPasswordField(); +} + +WTF::String inputElementText(Element* element) +{ + if (!element) + return WTF::String(); + + WTF::String elementText; + if (element->hasTagName(HTMLNames::inputTag)) { + const HTMLInputElement* inputElement = static_cast<const HTMLInputElement*>(element); + elementText = inputElement->value(); + } else if (element->hasTagName(HTMLNames::textareaTag)) { + const HTMLTextAreaElement* inputElement = static_cast<const HTMLTextAreaElement*>(element); + elementText = inputElement->value(); + } else if (element->isContentEditable()) { + RefPtr<Range> rangeForNode = rangeOfContents(element); + elementText = rangeForNode.get()->text(); + } + return elementText; +} + +bool isElementTypePlugin(const Element* element) +{ + if (!element) + return false; + + if (element->hasTagName(HTMLNames::objectTag) + || element->hasTagName(HTMLNames::embedTag) + || element->hasTagName(HTMLNames::appletTag)) + return true; + + return false; +} + +HTMLTextFormControlElement* toTextControlElement(Node* node) +{ + if (!(node && node->isElementNode())) + return 0; + + Element* element = static_cast<Element*>(node); + if (!element->isFormControlElement()) + return 0; + + HTMLFormControlElement* formElement = static_cast<HTMLFormControlElement*>(element); + if (!formElement->isTextFormControl()) + return 0; + + return static_cast<HTMLTextFormControlElement*>(formElement); +} + +bool isPopupInputField(const Element* element) +{ + return isDateTimeInputField(element) || isColorInputField(element); +} + +bool isDateTimeInputField(const Element* element) +{ + if (!element->hasTagName(HTMLNames::inputTag)) + return false; + + const HTMLInputElement* inputElement = static_cast<const HTMLInputElement*>(element); + + // The following types have popup's. + if (inputElement->isDateControl() + || inputElement->isDateTimeControl() + || inputElement->isDateTimeLocalControl() + || inputElement->isTimeControl() + || inputElement->isMonthControl()) + return true; + + return false; +} + +bool isColorInputField(const Element* element) +{ + if (!element->hasTagName(HTMLNames::inputTag)) + return false; + + const HTMLInputElement* inputElement = static_cast<const HTMLInputElement*>(element); + +#if ENABLE(INPUT_COLOR) + if (inputElement->isColorControl()) + return true; +#endif + + return false; +} + +AttributeState elementSupportsAutocorrect(const Element* element) +{ + // First we check the input item itself. If the attribute is not defined, + // we check its parent form. + QualifiedName autocorrectAttr = QualifiedName(nullAtom, "autocorrect", nullAtom); + if (element->fastHasAttribute(autocorrectAttr)) { + AtomicString attributeString = element->fastGetAttribute(autocorrectAttr); + if (equalIgnoringCase(attributeString, "off")) + return Off; + if (equalIgnoringCase(attributeString, "on")) + return On; + // If we haven't returned, it wasn't set properly. Check the form for an explicit setting + // because the attribute was provided, but invalid. + } + if (element->isFormControlElement()) { + const HTMLFormControlElement* formElement = static_cast<const HTMLFormControlElement*>(element); + if (formElement->form() && formElement->form()->fastHasAttribute(autocorrectAttr)) { + AtomicString attributeString = formElement->form()->fastGetAttribute(autocorrectAttr); + if (equalIgnoringCase(attributeString, "off")) + return Off; + if (equalIgnoringCase(attributeString, "on")) + return On; + } + } + + return Default; +} + +// Check if this is an input field that will be focused & require input support. +bool isTextBasedContentEditableElement(Element* element) +{ + if (!element) + return false; + + if (element->isReadOnlyFormControl()) + return false; + + if (isPopupInputField(element)) + return false; + + return element->isTextFormControl() || element->isContentEditable(); +} + +IntRect transformedBoundingBoxForRange(const Range& range) +{ + // Based on Range::boundingBox, which does not handle transforms, and + // RenderObject::absoluteBoundingBoxRect, which does. + IntRect result; + Vector<FloatQuad> quads; + visibleTextQuads(range, quads); + const size_t n = quads.size(); + for (size_t i = 0; i < n; ++i) + result.unite(quads[i].enclosingBoundingBox()); + + return result; +} + +VisibleSelection visibleSelectionForInputElement(Element* element) +{ + return visibleSelectionForRangeInputElement(element, 0, inputElementText(element).length()); +} + +VisibleSelection visibleSelectionForRangeInputElement(Element* element, int start, int end) +{ + if (DOMSupport::toTextControlElement(element)) { + RenderTextControl* textRender = toRenderTextControl(element->renderer()); + if (!textRender) + return VisibleSelection(); + + VisiblePosition startPosition = textRender->visiblePositionForIndex(start); + VisiblePosition endPosition; + if (start == end) + endPosition = startPosition; + else + endPosition = textRender->visiblePositionForIndex(end); + + return VisibleSelection(startPosition, endPosition); + } + + // Must be content editable, generate the range. + RefPtr<Range> selectionRange = TextIterator::rangeFromLocationAndLength(element, start, end - start); + if (start == end) + return VisibleSelection(selectionRange.get()->startPosition(), DOWNSTREAM); + + VisiblePosition visibleStart(selectionRange->startPosition(), DOWNSTREAM); + VisiblePosition visibleEnd(selectionRange->endPosition(), SEL_DEFAULT_AFFINITY); + + return VisibleSelection(visibleStart, visibleEnd); +} + +Node* DOMContainerNodeForPosition(const Position& position) +{ + Node* nodeAtPos = position.containerNode(); + if (nodeAtPos->isInShadowTree()) + nodeAtPos = nodeAtPos->shadowAncestorNode(); + + return nodeAtPos; +} + +bool isPositionInNode(Node* node, const Position& position) +{ + int offset = 0; + Node* domNodeAtPos = DOMContainerNodeForPosition(position); + if (domNodeAtPos == position.containerNode()) + offset = position.computeOffsetInContainerNode(); + + RefPtr<Range> rangeForNode = rangeOfContents(node); + int ec; + + return rangeForNode->isPointInRange(domNodeAtPos, offset, ec); +} + +// This is a Tristate return to allow us to override name matching when +// autocomplete is expressly requested for a field. Default indicates +// that the setting is On which is the default but not expressly requested +// for the element being checked. On indicates that it is directly added +// to the element. +AttributeState elementSupportsAutocomplete(const Element* element) +{ + if (!element->hasTagName(HTMLNames::inputTag)) + return Default; + + const HTMLInputElement* inputElement = static_cast<const HTMLInputElement*>(element); + if (inputElement->fastHasAttribute(HTMLNames::autocompleteAttr)) { + if (equalIgnoringCase(inputElement->fastGetAttribute(HTMLNames::autocompleteAttr), "on")) + return On; + } + + return inputElement->shouldAutocomplete() ? Default : Off; +} + +bool matchesReservedStringPreventingAutocomplete(AtomicString& string) +{ + if (string.contains("email", false /* caseSensitive */) + || string.contains("user", false /* caseSensitive */) + || string.contains("name", false /* caseSensitive */) + || string.contains("login", false /* caseSensitive */)) + return true; + + return false; +} + +// This checks to see if an input element has a name or id attribute set to +// username or email. These are rough checks to avoid major sites that use +// login fields as input type=text and auto correction interfers with. +bool elementIdOrNameIndicatesNoAutocomplete(const Element* element) +{ + if (!element->hasTagName(HTMLNames::inputTag)) + return false; + + AtomicString idAttribute = element->getIdAttribute(); + if (matchesReservedStringPreventingAutocomplete(idAttribute)) + return true; + + if (element->fastHasAttribute(HTMLNames::nameAttr)) { + AtomicString nameAttribute = element->fastGetAttribute(HTMLNames::nameAttr); + if (matchesReservedStringPreventingAutocomplete(nameAttribute)) + return true; + } + + return false; +} + +IntPoint convertPointToFrame(const Frame* sourceFrame, const Frame* targetFrame, const IntPoint& point) +{ + ASSERT(sourceFrame && targetFrame); + if (sourceFrame == targetFrame) + return point; + + ASSERT(sourceFrame->view() && targetFrame->view()); + ASSERT(targetFrame->tree()); + + Frame* targetFrameParent = targetFrame->tree()->parent(); + IntRect targetFrameRect = targetFrame->view()->frameRect(); + + // Convert the target frame rect to source window content coordinates. This is only required + // if the parent frame is not the source. If the parent is the source, subframeRect + // is already in source content coordinates. + if (targetFrameParent != sourceFrame) + targetFrameRect = sourceFrame->view()->windowToContents(targetFrameParent->view()->contentsToWindow(targetFrameRect)); + + // Requested point is outside of target frame, return InvalidPoint. + if (!targetFrameRect.contains(point)) + return InvalidPoint; + + // Adjust the points to be relative to the target. + return targetFrame->view()->windowToContents(sourceFrame->view()->contentsToWindow(point)); +} + +VisibleSelection visibleSelectionForClosestActualWordStart(const VisibleSelection& selection) +{ + // VisibleSelection validation has a special case when the caret is at the end of a paragraph where + // it selects the paragraph marker. As well, if the position is at the end of a word, it will select + // only the space between words. We want to select an actual word so we move the selection to + // the start of the leftmost word if the character after the selection point is whitespace. + if (selection.selectionType() != VisibleSelection::RangeSelection && isWhitespace(selection.visibleStart().characterAfter())) { + VisibleSelection leftSelection(previousWordPosition(selection.start())); + bool leftSelectionIsOnWord = !isWhitespace(leftSelection.visibleStart().characterAfter()); + + VisibleSelection rangeSelection(endOfWord(leftSelection.start()), selection.visibleStart()); + int leftDistance = TextIterator::rangeLength(rangeSelection.toNormalizedRange().get()); + + VisibleSelection rightSelection(nextWordPosition(selection.start())); + rightSelection = previousWordPosition(rightSelection.start()); + bool rightSelectionIsOnWord = !isWhitespace(rightSelection.visibleStart().characterAfter()); + + rangeSelection = VisibleSelection(rightSelection.visibleStart(), selection.visibleStart()); + int rightDistance = TextIterator::rangeLength(rangeSelection.toNormalizedRange().get()); + + // Make sure we found an actual word. If not, return the original selection. + if (!leftSelectionIsOnWord && !rightSelectionIsOnWord) + return selection; + + if (!rightSelectionIsOnWord || (leftSelectionIsOnWord && leftDistance < rightDistance)) { + // Left is closer or right is invalid. + return leftSelection; + } + + // Right is closer or equal, or left was invalid. + return rightSelection; + } + + // No adjustment required. + return selection; +} + +} // DOMSupport +} // WebKit +} // BlackBerry diff --git a/Source/WebKit/blackberry/WebKitSupport/DOMSupport.h b/Source/WebKit/blackberry/WebKitSupport/DOMSupport.h new file mode 100644 index 000000000..1e0945189 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/DOMSupport.h @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef DOMSupport_h +#define DOMSupport_h + +#include "IntPoint.h" +#include "IntRect.h" + +#include <wtf/Vector.h> + +namespace WTF { +class String; +} + +namespace WebCore { +class Element; +class FloatQuad; +class Frame; +class HTMLTextFormControlElement; +class Node; +class Position; +class Range; +class VisibleSelection; +} + +namespace BlackBerry { +namespace WebKit { +namespace DOMSupport { + +enum AttributeState { On, Off, Default }; + +bool isElementTypePlugin(const WebCore::Element*); + +bool isTextInputElement(WebCore::Element*); +bool isTextBasedContentEditableElement(WebCore::Element*); +bool isPasswordElement(const WebCore::Element*); + +bool isPopupInputField(const WebCore::Element*); +bool isDateTimeInputField(const WebCore::Element*); +bool isColorInputField(const WebCore::Element*); +AttributeState elementSupportsAutocorrect(const WebCore::Element*); + +WTF::String inputElementText(WebCore::Element*); + +WebCore::HTMLTextFormControlElement* toTextControlElement(WebCore::Node*); + +WebCore::IntRect transformedBoundingBoxForRange(const WebCore::Range&); +void visibleTextQuads(const WebCore::Range&, WTF::Vector<WebCore::FloatQuad>& quads, bool useSelectionHeight = false); + +WebCore::VisibleSelection visibleSelectionForRangeInputElement(WebCore::Element*, int start, int end); +WebCore::VisibleSelection visibleSelectionForInputElement(WebCore::Element*); + +WebCore::Node* DOMContainerNodeForPosition(const WebCore::Position&); +bool isPositionInNode(WebCore::Node*, const WebCore::Position&); + +AttributeState elementSupportsAutocomplete(const WebCore::Element*); +bool elementIdOrNameIndicatesNoAutocomplete(const WebCore::Element*); + +WebCore::IntPoint convertPointToFrame(const WebCore::Frame* sourceFrame, const WebCore::Frame* targetFrame, const WebCore::IntPoint& sourcePoint); + +static const WebCore::IntPoint InvalidPoint = WebCore::IntPoint(-1, -1); + +WebCore::VisibleSelection visibleSelectionForClosestActualWordStart(const WebCore::VisibleSelection&); + +} // DOMSupport +} // WebKit +} // BlackBerry + +#endif // DOMSupport_h diff --git a/Source/WebKit/blackberry/WebKitSupport/FatFingers.cpp b/Source/WebKit/blackberry/WebKitSupport/FatFingers.cpp new file mode 100644 index 000000000..016a42620 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/FatFingers.cpp @@ -0,0 +1,537 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "FatFingers.h" + +#include "BlackBerryPlatformLog.h" +#include "BlackBerryPlatformScreen.h" +#include "BlackBerryPlatformSettings.h" +#include "CSSComputedStyleDeclaration.h" +#include "CSSParser.h" +#include "DOMSupport.h" +#include "Document.h" +#include "Element.h" +#include "EventNames.h" +#include "ExceptionCode.h" +#include "FloatQuad.h" +#include "Frame.h" +#include "FrameView.h" +#include "HTMLFrameOwnerElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "HTMLTextAreaElement.h" +#include "Range.h" +#include "RenderObject.h" +#include "RenderView.h" +#include "Text.h" +#include "TextBreakIterator.h" +#include "WebPage_p.h" + +#if DEBUG_FAT_FINGERS +#include "BackingStore.h" +#endif + +using BlackBerry::Platform::LogLevelInfo; +using BlackBerry::Platform::log; +using BlackBerry::Platform::IntRectRegion; +using WTF::RefPtr; + +using namespace WebCore; + +// Lets make the top padding bigger than other directions, since it gets us more +// accurate clicking results. + +namespace BlackBerry { +namespace WebKit { + +#if DEBUG_FAT_FINGERS +IntRect FatFingers::m_debugFatFingerRect; +IntPoint FatFingers::m_debugFatFingerClickPosition; +IntPoint FatFingers::m_debugFatFingerAdjustedPosition; +#endif + +IntRect FatFingers::fingerRectForPoint(const IntPoint& point) const +{ + unsigned topPadding, rightPadding, bottomPadding, leftPadding; + getPaddings(topPadding, rightPadding, bottomPadding, leftPadding); + + return HitTestResult::rectForPoint(point, topPadding, rightPadding, bottomPadding, leftPadding); +} + +static bool hasMousePressListener(Element* element) +{ + ASSERT(element); + return element->hasEventListeners(eventNames().clickEvent) + || element->hasEventListeners(eventNames().mousedownEvent) + || element->hasEventListeners(eventNames().mouseupEvent); +} + +bool FatFingers::isElementClickable(Element* element) const +{ + ASSERT(element); + ASSERT(m_matchingApproach != Done); + ASSERT(m_targetType == ClickableElement); + + switch (m_matchingApproach) { + case ClickableByDefault: { + ExceptionCode ec = 0; + return element->webkitMatchesSelector("a[href],*:link,*:visited,*[role=button],button,input,select,label[for],area[href],textarea,embed,object", ec) + || element->isMediaControlElement() + || element->isContentEditable(); + } + case MadeClickableByTheWebpage: + + // Elements within a shadow DOM can not be 'made clickable by the webpage', since + // they are not accessible. + if (element->isInShadowTree()) + return false; + + // FIXME: We fall back to checking for the presence of CSS style "cursor: pointer" to indicate whether the element A + // can be clicked when A neither registers mouse events handlers nor is a hyperlink or form control. This workaround + // ensures that we don't break various Google web apps, including <http://maps.google.com>. Ideally, we should walk + // up the DOM hierarchy to determine the first parent element that accepts mouse events. + // Consider the HTML snippet: <div id="A" onclick="..."><div id="B">Example</div></div> + // Notice, B is not a hyperlink, or form control, and does not register any mouse event handler. Then B cannot + // be clicked. Suppose B specified the CSS property "cursor: pointer". Then, B will be considered as clickable. + return hasMousePressListener(element) + || computedStyle(element)->getPropertyValue(cssPropertyID("cursor")) == "pointer"; + default: + ASSERT_NOT_REACHED(); + } + + return false; +} + +// FIXME: Handle content editable nodes here too. +static inline bool isFieldWithText(Node* node) +{ + ASSERT(node); + if (!node || !node->isElementNode()) + return false; + + Element* element = toElement(node); + return !DOMSupport::inputElementText(element).isEmpty(); +} + +static inline int distanceBetweenPoints(const IntPoint& p1, const IntPoint& p2) +{ + int dx = p1.x() - p2.x(); + int dy = p1.y() - p2.y(); + return sqrt((double)((dx * dx) + (dy * dy))); +} + +static bool compareDistanceBetweenPoints(const Platform::IntPoint& p, const Platform::IntRectRegion& r1, const Platform::IntRectRegion& r2) +{ + return distanceBetweenPoints(p, r1.extents().center()) > distanceBetweenPoints(p, r2.extents().center()); +} + +static bool isValidFrameOwner(WebCore::Element* element) +{ + ASSERT(element); + return element->isFrameOwnerElement() && static_cast<HTMLFrameOwnerElement*>(element)->contentFrame(); +} + +// NOTE: 'contentPos' is in main frame contents coordinates. +FatFingers::FatFingers(WebPagePrivate* webPage, const WebCore::IntPoint& contentPos, TargetType targetType) + : m_webPage(webPage) + , m_contentPos(contentPos) + , m_targetType(targetType) + , m_matchingApproach(Done) +{ + ASSERT(webPage); + +#if DEBUG_FAT_FINGERS + m_debugFatFingerRect = IntRect(0, 0, 0, 0); + m_debugFatFingerClickPosition = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(contentPos)); + m_debugFatFingerAdjustedPosition = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(contentPos)); +#endif +} + +FatFingers::~FatFingers() +{ +} + +const FatFingersResult FatFingers::findBestPoint() +{ + ASSERT(m_webPage); + ASSERT(m_webPage->m_mainFrame); + + m_cachedRectHitTestResults.clear(); + + FatFingersResult result(m_contentPos); + m_matchingApproach = ClickableByDefault; + + // Lets set nodeUnderFatFinger to the result of a point based hit test here. If something + // targable is actually found by ::findIntersectingRegions, then we might replace what we just set below later on. + Element* elementUnderPoint; + Element* clickableElementUnderPoint; + getRelevantInfoFromPoint(m_webPage->m_mainFrame->document(), m_contentPos, elementUnderPoint, clickableElementUnderPoint); + + if (elementUnderPoint) { + result.m_nodeUnderFatFinger = elementUnderPoint; + + // If we are looking for a Clickable Element and we found one, we can quit early. + if (m_targetType == ClickableElement) { + if (clickableElementUnderPoint) { + setSuccessfulFatFingersResult(result, clickableElementUnderPoint, m_contentPos /*adjustedPosition*/); + return result; + } + + if (isElementClickable(elementUnderPoint)) { + setSuccessfulFatFingersResult(result, elementUnderPoint, m_contentPos /*adjustedPosition*/); + return result; + } + } + } + +#if DEBUG_FAT_FINGERS + // Force blit to make the fat fingers rects show up. + if (!m_debugFatFingerRect.isEmpty()) + m_webPage->m_backingStore->repaint(0, 0, m_webPage->transformedViewportSize().width(), m_webPage->transformedViewportSize().height(), true, true); +#endif + + Vector<IntersectingRegion> intersectingRegions; + Platform::IntRectRegion remainingFingerRegion = Platform::IntRectRegion(fingerRectForPoint(m_contentPos)); + + bool foundOne = findIntersectingRegions(m_webPage->m_mainFrame->document(), intersectingRegions, remainingFingerRegion); + if (!foundOne) { + m_matchingApproach = MadeClickableByTheWebpage; + remainingFingerRegion = Platform::IntRectRegion(fingerRectForPoint(m_contentPos)); + foundOne = findIntersectingRegions(m_webPage->m_mainFrame->document(), intersectingRegions, remainingFingerRegion); + } + + m_matchingApproach = Done; + m_cachedRectHitTestResults.clear(); + + if (!foundOne) + return result; + + Node* bestNode = 0; + Platform::IntRectRegion largestIntersectionRegion; + IntPoint bestPoint; + int largestIntersectionRegionArea = 0; + + Vector<IntersectingRegion>::const_iterator endIt = intersectingRegions.end(); + for (Vector<IntersectingRegion>::const_iterator it = intersectingRegions.begin(); it != endIt; ++it) { + Node* currentNode = it->first; + Platform::IntRectRegion currentIntersectionRegion = it->second; + + int currentIntersectionRegionArea = currentIntersectionRegion.area(); + if (currentIntersectionRegionArea > largestIntersectionRegionArea + || (currentIntersectionRegionArea == largestIntersectionRegionArea + && compareDistanceBetweenPoints(m_contentPos, currentIntersectionRegion, largestIntersectionRegion))) { + bestNode = currentNode; + largestIntersectionRegion = currentIntersectionRegion; + largestIntersectionRegionArea = currentIntersectionRegionArea; + } + } + + if (!bestNode || largestIntersectionRegion.isEmpty()) + return result; + +#if DEBUG_FAT_FINGERS + m_debugFatFingerAdjustedPosition = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(largestIntersectionRegion.rects()[0].center())); +#endif + + setSuccessfulFatFingersResult(result, bestNode, largestIntersectionRegion.rects()[0].center() /*adjustedPosition*/); + + return result; +} + +// 'region' is in contents coordinates relative to the frame containing 'node' +// 'remainingFingerRegion' and 'intersectingRegions' will always be in main frame contents +// coordinates. +// Thus, before comparing, we need to map the former to main frame contents coordinates. +bool FatFingers::checkFingerIntersection(const Platform::IntRectRegion& region, + const Platform::IntRectRegion& remainingFingerRegion, + Node* node, Vector<IntersectingRegion>& intersectingRegions) +{ + ASSERT(node); + + Platform::IntRectRegion regionCopy(region); + WebCore::IntPoint framePos(m_webPage->frameOffset(node->document()->frame())); + regionCopy.move(framePos.x(), framePos.y()); + + Platform::IntRectRegion intersection = intersectRegions(regionCopy, remainingFingerRegion); + if (intersection.isEmpty()) + return false; + +#if DEBUG_FAT_FINGERS + String nodeName; + if (node->isTextNode()) + nodeName = "text node"; + else if (node->isElementNode()) + nodeName = String::format("%s node", toElement(node)->tagName().latin1().data()); + else + nodeName = "unknown node"; + log(LogLevelInfo, "%s has region %s, intersecting at %s (area %d)", nodeName.latin1().data(), + regionCopy.toString().c_str(), intersection.toString().c_str(), intersection.area()); +#endif + + intersectingRegions.append(std::make_pair(node, intersection)); + return true; +} + + +// intersectingRegions and remainingFingerRegion are all in main frame contents coordinates, +// even on recursive calls of ::findIntersectingRegions. +bool FatFingers::findIntersectingRegions(Document* document, + Vector<IntersectingRegion>& intersectingRegions, Platform::IntRectRegion& remainingFingerRegion) +{ + if (!document || !document->frame()->view()) + return false; + + // The layout needs to be up-to-date to determine if a node is focusable. + document->updateLayoutIgnorePendingStylesheets(); + + // Create fingerRect. + IntPoint frameContentPos(document->frame()->view()->windowToContents(m_webPage->m_mainFrame->view()->contentsToWindow(m_contentPos))); + +#if DEBUG_FAT_FINGERS + IntRect fingerRect(fingerRectForPoint(frameContentPos)); + IntRect screenFingerRect = m_webPage->mapToTransformed(fingerRect); + log(LogLevelInfo, "fat finger rect now %s", screenFingerRect.toString().latin1().data()); + + // only record the first finger rect + if (document == m_webPage->m_mainFrame->document()) + m_debugFatFingerRect = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(fingerRect)); +#endif + + bool foundOne = false; + + RenderLayer* lowestPositionedEnclosingLayerSoFar = 0; + + // Iterate over the list of nodes (and subrects of nodes where possible), for each saving the + // intersection of the bounding box with the finger rect. + ListHashSet<RefPtr<Node> > intersectedNodes; + getNodesFromRect(document, frameContentPos, intersectedNodes); + + ListHashSet<RefPtr<Node> >::const_iterator it = intersectedNodes.begin(); + ListHashSet<RefPtr<Node> >::const_iterator end = intersectedNodes.end(); + for ( ; it != end; ++it) { + Node* curNode = (*it).get(); + if (!curNode || !curNode->renderer()) + continue; + + if (remainingFingerRegion.isEmpty()) + break; + + bool isElement = curNode->isElementNode(); + if (isElement && isValidFrameOwner(toElement(curNode))) { + + HTMLFrameOwnerElement* owner = static_cast<HTMLFrameOwnerElement*>(curNode); + Document* childDocument = owner && owner->contentFrame() ? owner->contentFrame()->document() : 0; + if (!childDocument) + continue; + + ASSERT(childDocument->frame()->view()); + + foundOne |= findIntersectingRegions(childDocument, intersectingRegions, remainingFingerRegion); + } else if (isElement && m_targetType == ClickableElement) { + foundOne |= checkForClickableElement(toElement(curNode), intersectingRegions, remainingFingerRegion, lowestPositionedEnclosingLayerSoFar); + } else if (m_targetType == Text) + foundOne |= checkForText(curNode, intersectingRegions, remainingFingerRegion); + } + + return foundOne; +} + +bool FatFingers::checkForClickableElement(Element* curElement, + Vector<IntersectingRegion>& intersectingRegions, + Platform::IntRectRegion& remainingFingerRegion, + RenderLayer*& lowestPositionedEnclosingLayerSoFar) +{ + ASSERT(curElement); + + bool intersects = false; + Platform::IntRectRegion elementRegion; + + bool isClickableElement = isElementClickable(curElement); + if (isClickableElement) { + if (curElement->isLink()) { + // Links can wrap lines, and in such cases Node::getRect() can give us + // not accurate rects, since it unites all InlineBox's rects. In these + // cases, we can process each line of the link separately with our + // intersection rect, getting a more accurate clicking. + Vector<FloatQuad> quads; + curElement->renderer()->absoluteFocusRingQuads(quads); + + size_t n = quads.size(); + ASSERT(n); + + for (size_t i = 0; i < n; ++i) + elementRegion = unionRegions(elementRegion, Platform::IntRect(quads[i].enclosingBoundingBox())); + } else + elementRegion = Platform::IntRectRegion(curElement->renderer()->absoluteBoundingBoxRect(true /*use transforms*/)); + + } else + elementRegion = Platform::IntRectRegion(curElement->renderer()->absoluteBoundingBoxRect(true /*use transforms*/)); + + if (lowestPositionedEnclosingLayerSoFar) { + RenderLayer* curElementRenderLayer = m_webPage->enclosingPositionedAncestorOrSelfIfPositioned(curElement->renderer()->enclosingLayer()); + if (curElementRenderLayer != lowestPositionedEnclosingLayerSoFar) { + + // elementRegion will always be in contents coordinates of its container frame. It needs to be + // mapped to main frame contents coordinates in order to subtract the fingerRegion, then. + WebCore::IntPoint framePos(m_webPage->frameOffset(curElement->document()->frame())); + Platform::IntRectRegion layerRegion(Platform::IntRect(lowestPositionedEnclosingLayerSoFar->renderer()->absoluteBoundingBoxRect(true/*use transforms*/))); + layerRegion.move(framePos.x(), framePos.y()); + + remainingFingerRegion = subtractRegions(remainingFingerRegion, layerRegion); + + lowestPositionedEnclosingLayerSoFar = curElementRenderLayer; + } + } else + lowestPositionedEnclosingLayerSoFar = m_webPage->enclosingPositionedAncestorOrSelfIfPositioned(curElement->renderer()->enclosingLayer()); + + if (isClickableElement) + intersects = checkFingerIntersection(elementRegion, remainingFingerRegion, curElement, intersectingRegions); + + return intersects; +} + +bool FatFingers::checkForText(Node* curNode, Vector<IntersectingRegion>& intersectingRegions, Platform::IntRectRegion& fingerRegion) +{ + ASSERT(curNode); + if (isFieldWithText(curNode)) { + // FIXME: Find all text in the field and find the best word. + // For now, we will just select the whole field. + IntRect boundingRect = curNode->renderer()->absoluteBoundingBoxRect(true /*use transforms*/); + Platform::IntRectRegion nodeRegion(boundingRect); + return checkFingerIntersection(nodeRegion, fingerRegion, curNode, intersectingRegions); + } + + if (curNode->isTextNode()) { + WebCore::Text* curText = static_cast<WebCore::Text*>(curNode); + String allText = curText->wholeText(); + + // Iterate through all words, breaking at whitespace, to find the bounding box of each word. + TextBreakIterator* wordIterator = wordBreakIterator(allText.characters(), allText.length()); + + int lastOffset = textBreakFirst(wordIterator); + if (lastOffset == -1) + return false; + + bool foundOne = false; + int offset; + Document* document = curNode->document(); + + while ((offset = textBreakNext(wordIterator)) != -1) { + RefPtr<Range> range = Range::create(document, curText, lastOffset, curText, offset); + if (!range->text().stripWhiteSpace().isEmpty()) { +#if DEBUG_FAT_FINGERS + log(LogLevelInfo, "Checking word '%s'", range->text().latin1().data()); +#endif + Platform::IntRectRegion rangeRegion(DOMSupport::transformedBoundingBoxForRange(*range)); + foundOne |= checkFingerIntersection(rangeRegion, fingerRegion, curNode, intersectingRegions); + } + lastOffset = offset; + } + return foundOne; + } + return false; +} + +void FatFingers::getPaddings(unsigned& top, unsigned& right, unsigned& bottom, unsigned& left) const +{ + static unsigned topPadding = Platform::Settings::get()->topFatFingerPadding(); + static unsigned rightPadding = Platform::Settings::get()->rightFatFingerPadding(); + static unsigned bottomPadding = Platform::Settings::get()->bottomFatFingerPadding(); + static unsigned leftPadding = Platform::Settings::get()->leftFatFingerPadding(); + + double currentScale = m_webPage->currentScale(); + top = topPadding / currentScale; + right = rightPadding / currentScale; + bottom = bottomPadding / currentScale; + left = leftPadding / currentScale; +} + +FatFingers::CachedResultsStrategy FatFingers::cachingStrategy() const +{ + switch (m_matchingApproach) { + case ClickableElement: + return GetFromRenderTree; + case MadeClickableByTheWebpage: + return GetFromCache; + case Done: + default: + ASSERT_NOT_REACHED(); + return GetFromRenderTree; + } +} + +void FatFingers::getNodesFromRect(Document* document, const IntPoint& contentPos, ListHashSet<RefPtr<WebCore::Node> >& intersectedNodes) +{ + FatFingers::CachedResultsStrategy cacheResolvingStrategy = cachingStrategy(); + + if (cacheResolvingStrategy == GetFromCache) { + ASSERT(m_cachedRectHitTestResults.contains(document)); + intersectedNodes = m_cachedRectHitTestResults.get(document); + return; + } + + ASSERT(cacheResolvingStrategy == GetFromRenderTree); + + unsigned topPadding, rightPadding, bottomPadding, leftPadding; + getPaddings(topPadding, rightPadding, bottomPadding, leftPadding); + + HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping); + HitTestResult result(contentPos, topPadding, rightPadding, bottomPadding, leftPadding, HitTestShadowDOM); + + document->renderView()->layer()->hitTest(request, result); + intersectedNodes = result.rectBasedTestResult(); + m_cachedRectHitTestResults.add(document, intersectedNodes); +} + +void FatFingers::getRelevantInfoFromPoint(Document* document, const IntPoint& contentPos, Element*& elementUnderPoint, Element*& clickableElementUnderPoint) const +{ + elementUnderPoint = 0; + clickableElementUnderPoint = 0; + + if (!document || !document->renderer() || !document->frame()) + return; + + HitTestResult result = document->frame()->eventHandler()->hitTestResultAtPoint(contentPos, true /*allowShadowContent*/); + Node* node = result.innerNode(); + while (node && !node->isElementNode()) + node = node->parentNode(); + + elementUnderPoint = static_cast<Element*>(node); + clickableElementUnderPoint = result.URLElement(); +} + +void FatFingers::setSuccessfulFatFingersResult(FatFingersResult& result, Node* bestNode, const WebCore::IntPoint& adjustedPoint) +{ + result.m_nodeUnderFatFinger = bestNode; + result.m_adjustedPosition = adjustedPoint; + result.m_positionWasAdjusted = true; + result.m_isValid = true; + + bool isTextInputElement = false; + if (m_targetType == ClickableElement) { + ASSERT(bestNode->isElementNode()); + Element* bestElement = static_cast<Element*>(bestNode); + isTextInputElement = DOMSupport::isTextInputElement(bestElement); + } + result.m_isTextInput = isTextInputElement; +} + +} +} + diff --git a/Source/WebKit/blackberry/WebKitSupport/FatFingers.h b/Source/WebKit/blackberry/WebKitSupport/FatFingers.h new file mode 100644 index 000000000..cb31f977a --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/FatFingers.h @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef FatFingers_h +#define FatFingers_h + +#include "HitTestResult.h" +#include "RenderLayer.h" + +#include <BlackBerryPlatformIntRectRegion.h> + +#include <utility> + +#include <wtf/HashSet.h> +#include <wtf/ListHashSet.h> +#include <wtf/Vector.h> + +namespace WebCore { +class Document; +class Element; +class IntPoint; +class IntRect; +class IntSize; +class Node; +} + +#define DEBUG_FAT_FINGERS 0 + +namespace BlackBerry { +namespace WebKit { + +class WebPagePrivate; +class FatFingers; +class TouchEventHandler; + +class FatFingersResult { +public: + + FatFingersResult(const WebCore::IntPoint& p = WebCore::IntPoint::zero()) + : m_originalPosition(p) + , m_adjustedPosition(p) + , m_positionWasAdjusted(false) + , m_isTextInput(false) + , m_isValid(false) + , m_nodeUnderFatFinger(0) + { + } + + void reset() + { + m_originalPosition = m_adjustedPosition = WebCore::IntPoint::zero(); + m_positionWasAdjusted = false; + m_isTextInput = false; + m_isValid = false; + m_nodeUnderFatFinger = 0; + } + + WebCore::IntPoint originPosition() const { return m_originalPosition; } + WebCore::IntPoint adjustedPosition() const { return m_adjustedPosition; } + bool positionWasAdjusted() const { return m_isValid && m_positionWasAdjusted; } + bool isTextInput() const { return m_isValid && !!m_nodeUnderFatFinger && m_isTextInput; } + bool isValid() const { return m_isValid; } + + enum ContentType { ShadowContentAllowed, ShadowContentNotAllowed }; + + WebCore::Node* node(ContentType type = ShadowContentAllowed) const + { + if (!m_nodeUnderFatFinger || !m_nodeUnderFatFinger->inDocument()) + return 0; + + WebCore::Node* result = m_nodeUnderFatFinger.get(); + + if (type == ShadowContentAllowed) + return result; + + // Shadow trees can be nested. + while (result->isInShadowTree()) + result = toElement(result->shadowAncestorNode()); + + return result; + } + + WebCore::Element* nodeAsElementIfApplicable(ContentType type = ShadowContentAllowed) const + { + WebCore::Node* result = node(type); + if (!result || !result->isElementNode()) + return 0; + + return static_cast<WebCore::Element*>(result); + } + +private: + friend class WebKit::FatFingers; + friend class WebKit::TouchEventHandler; + + WebCore::IntPoint m_originalPosition; // Main frame contents coordinates. + WebCore::IntPoint m_adjustedPosition; // Main frame contents coordinates. + bool m_positionWasAdjusted; + bool m_isTextInput; // Check if the element under the touch point will require a VKB be displayed so that + // the touch down can be suppressed. + bool m_isValid; + RefPtr<WebCore::Node> m_nodeUnderFatFinger; +}; + +class FatFingers { +public: + enum TargetType { ClickableElement, Text }; + + FatFingers(WebPagePrivate* webpage, const WebCore::IntPoint& contentPos, TargetType); + ~FatFingers(); + + const FatFingersResult findBestPoint(); + +#if DEBUG_FAT_FINGERS + // These debug vars are all in content coordinates. They are public so + // they can be read from BackingStore, which will draw a visible rect + // around the fat fingers area. + static WebCore::IntRect m_debugFatFingerRect; + static WebCore::IntPoint m_debugFatFingerClickPosition; + static WebCore::IntPoint m_debugFatFingerAdjustedPosition; +#endif + +private: + enum MatchingApproachForClickable { ClickableByDefault = 0, MadeClickableByTheWebpage, Done }; + + typedef std::pair<WebCore::Node*, Platform::IntRectRegion> IntersectingRegion; + + enum CachedResultsStrategy { GetFromRenderTree = 0, GetFromCache }; + CachedResultsStrategy cachingStrategy() const; + typedef HashMap<RefPtr<WebCore::Document>, ListHashSet<RefPtr<WebCore::Node> > > CachedRectHitTestResults; + + bool checkFingerIntersection(const Platform::IntRectRegion&, + const Platform::IntRectRegion& remainingFingerRegion, + WebCore::Node*, + Vector<IntersectingRegion>& intersectingRegions); + + bool findIntersectingRegions(WebCore::Document*, + Vector<IntersectingRegion>& intersectingRegions, + Platform::IntRectRegion& remainingFingerRegion); + + bool checkForClickableElement(WebCore::Element*, + Vector<IntersectingRegion>& intersectingRegions, + Platform::IntRectRegion& remainingFingerRegion, + WebCore::RenderLayer*& lowestPositionedEnclosingLayerSoFar); + + bool checkForText(WebCore::Node*, + Vector<IntersectingRegion>& intersectingRegions, + Platform::IntRectRegion& fingerRegion); + + void setSuccessfulFatFingersResult(FatFingersResult&, WebCore::Node*, const WebCore::IntPoint&); + + void getNodesFromRect(WebCore::Document*, const WebCore::IntPoint&, ListHashSet<RefPtr<WebCore::Node> >&); + + // It mimics Document::elementFromPoint, but recursively hit-tests in case an inner frame is found. + void getRelevantInfoFromPoint(WebCore::Document*, + const WebCore::IntPoint&, + WebCore::Element*& elementUnderPoint, + WebCore::Element*& clickableElementUnderPoint) const; + + bool isElementClickable(WebCore::Element*) const; + + inline WebCore::IntRect fingerRectForPoint(const WebCore::IntPoint&) const; + void getPaddings(unsigned& top, unsigned& right, unsigned& bottom, unsigned& left) const; + + WebPagePrivate* m_webPage; + WebCore::IntPoint m_contentPos; + TargetType m_targetType; + MatchingApproachForClickable m_matchingApproach; + CachedRectHitTestResults m_cachedRectHitTestResults; +}; + +} +} + +#endif // FatFingers_h + diff --git a/Source/WebKit/blackberry/WebKitSupport/GLES2Context.cpp b/Source/WebKit/blackberry/WebKitSupport/GLES2Context.cpp new file mode 100644 index 000000000..55b9e15dd --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/GLES2Context.cpp @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "GLES2Context.h" + +#include "Assertions.h" +#include "BackingStoreCompositingSurface.h" +#include "Chrome.h" +#include "ChromeClient.h" +#include "SurfacePool.h" +#include "WebPageClient.h" +#include "WebPage_p.h" + +#include <GLES2/gl2.h> + +namespace BlackBerry { +namespace WebKit { + +BackingStoreCompositingSurface* GLES2Context::compositingSurface() const +{ + return SurfacePool::globalSurfacePool()->compositingSurface(); +} + +Platform::Graphics::Buffer* GLES2Context::buffer() const +{ + if (m_window) + return m_window->buffer(); + +#if ENABLE_COMPOSITING_SURFACE + if (BackingStoreCompositingSurface* surface = compositingSurface()) + return surface->backBuffer()->nativeBuffer(); +#endif + + ASSERT_NOT_REACHED(); + return 0; +} + +PassOwnPtr<GLES2Context> GLES2Context::create(WebPagePrivate* page) +{ + return adoptPtr(new GLES2Context(page)); +} + +GLES2Context::GLES2Context(WebPagePrivate* page) + : m_window(0) +{ + if (page->m_client->window()->windowUsage() == Platform::Graphics::Window::GLES2Usage) + m_window = page->m_client->window(); +} + +GLES2Context::~GLES2Context() +{ +} + +Platform::IntSize GLES2Context::surfaceSize() const +{ + if (m_window) + return m_window->surfaceSize(); + +#if ENABLE_COMPOSITING_SURFACE + if (BackingStoreCompositingSurface* surface = compositingSurface()) + return surface->backBuffer()->surfaceSize(); +#endif + + ASSERT_NOT_REACHED(); + return Platform::IntSize(); +} + +bool GLES2Context::makeCurrent() +{ + Platform::Graphics::makeBufferCurrent(buffer(), Platform::Graphics::GLES2); + return true; +} + +bool GLES2Context::swapBuffers() +{ + ASSERT(glGetError() == GL_NO_ERROR); + +#if ENABLE_COMPOSITING_SURFACE + // Because we are rendering compositing contents into an off-screen pixmap and + // we need to blend the pixmap with the web page window surface we have to call + // glFinish() here. + glFinish(); + + if (BackingStoreCompositingSurface* surface = compositingSurface()) + surface->swapBuffers(); +#endif + + return true; +} + +} // namespace WebKit +} // namespace BlackBerry diff --git a/Source/WebKit/chromium/src/BoundObject.cpp b/Source/WebKit/blackberry/WebKitSupport/GLES2Context.h index d0f66aac5..ce7e84694 100644 --- a/Source/WebKit/chromium/src/BoundObject.cpp +++ b/Source/WebKit/blackberry/WebKitSupport/GLES2Context.h @@ -1,5 +1,6 @@ /* * Copyright (C) 2010 Google Inc. All rights reserved. + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -28,53 +29,38 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "config.h" -#include "BoundObject.h" +#ifndef GLES2Context_h +#define GLES2Context_h -#include "V8Binding.h" -#include "V8Proxy.h" +#include <BlackBerryPlatformGLES2Context.h> +#include <BlackBerryPlatformWindow.h> +#include <wtf/Noncopyable.h> +#include <wtf/PassOwnPtr.h> +namespace BlackBerry { namespace WebKit { -BoundObject::BoundObject(v8::Handle<v8::Context> context, void* v8This, const char* objectName) - : m_objectName(objectName) - , m_context(context) - , m_v8This(v8This) -{ - v8::Context::Scope contextScope(context); - v8::Local<v8::FunctionTemplate> localTemplate = v8::FunctionTemplate::New(WebCore::V8Proxy::checkNewLegal); - m_hostTemplate = v8::Persistent<v8::FunctionTemplate>::New(localTemplate); - m_hostTemplate->SetClassName(v8::String::New(objectName)); -} +class BackingStoreCompositingSurface; +class WebPagePrivate; -BoundObject::~BoundObject() -{ - m_hostTemplate.Dispose(); -} +class GLES2Context : public Platform::Graphics::GLES2Context { + WTF_MAKE_NONCOPYABLE(GLES2Context); +public: + static PassOwnPtr<GLES2Context> create(WebPagePrivate*); + ~GLES2Context(); + Platform::IntSize surfaceSize() const; + bool makeCurrent(); + bool swapBuffers(); -void BoundObject::addProtoFunction(const char* name, v8::InvocationCallback callback) -{ - v8::Context::Scope contextScope(m_context); - v8::Local<v8::Signature> signature = v8::Signature::New(m_hostTemplate); - v8::Local<v8::ObjectTemplate> proto = m_hostTemplate->PrototypeTemplate(); - v8::Local<v8::External> v8This = v8::External::New(m_v8This); - proto->Set( - v8::String::New(name), - v8::FunctionTemplate::New( - callback, - v8This, - signature), - static_cast<v8::PropertyAttribute>(v8::DontDelete)); -} +private: + GLES2Context(WebPagePrivate*); + BackingStoreCompositingSurface* compositingSurface() const; + Platform::Graphics::Buffer* buffer() const; -void BoundObject::build() -{ - v8::Context::Scope contextScope(m_context); - v8::Local<v8::Function> constructor = m_hostTemplate->GetFunction(); - v8::Local<v8::Object> boundObject = WebCore::SafeAllocation::newInstance(constructor); - - v8::Handle<v8::Object> global = m_context->Global(); - global->Set(v8::String::New(m_objectName), boundObject); -} + Platform::Graphics::Window* m_window; +}; } // namespace WebKit +} // namespace BlackBerry + +#endif diff --git a/Source/WebKit/blackberry/WebKitSupport/InPageSearchManager.cpp b/Source/WebKit/blackberry/WebKitSupport/InPageSearchManager.cpp new file mode 100644 index 000000000..ae0402100 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/InPageSearchManager.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "InPageSearchManager.h" + +#include "Document.h" +#include "DocumentMarkerController.h" +#include "Editor.h" +#include "Frame.h" +#include "Page.h" +#include "WebPage_p.h" + +static const int TextMatchMarkerLimit = 100; + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { + +InPageSearchManager::InPageSearchManager(WebPagePrivate* page) + : m_webPage(page) + , m_activeMatch(0) +{ +} + +InPageSearchManager::~InPageSearchManager() +{ +} + +bool InPageSearchManager::findNextString(const String& text, bool forward) +{ + if (!text.length()) { + clearTextMatches(); + m_activeSearchString = String(); + return false; + } + + if (m_activeSearchString != text) { + clearTextMatches(); + m_activeSearchString = text; + m_activeMatchCount = m_webPage->m_page->markAllMatchesForText(text, WebCore::CaseInsensitive, true, TextMatchMarkerLimit); + } else + setMarkerActive(m_activeMatch.get(), false); + + if (!m_activeMatchCount) + return false; + + const FindOptions findOptions = (forward ? 0 : WebCore::Backwards) + | WebCore::CaseInsensitive + | WebCore::WrapAround; // TODO should wrap around in page, not in frame + + // TODO StartInSelection + + m_activeMatch = m_webPage->mainFrame()->editor()->findStringAndScrollToVisible(text, m_activeMatch.get(), findOptions); + setMarkerActive(m_activeMatch.get(), true); + + return true; +} + +void InPageSearchManager::clearTextMatches() +{ + m_webPage->m_page->unmarkAllTextMatches(); + m_activeMatch = 0; +} + +void InPageSearchManager::setMarkerActive(WebCore::Range* range, bool active) +{ + if (!range) + return; + WebCore::Document* doc = m_webPage->mainFrame()->document(); + if (!doc) + return; + doc->markers()->setMarkersActive(range, active); +} + +} +} diff --git a/Source/WebKit/blackberry/WebKitSupport/InPageSearchManager.h b/Source/WebKit/blackberry/WebKitSupport/InPageSearchManager.h new file mode 100644 index 000000000..1f6bbb535 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/InPageSearchManager.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef InPageSearchManager_h +#define InPageSearchManager_h + +#include "WTFString.h" + +#include <wtf/RefPtr.h> + +namespace WebCore { +class Range; +} + +namespace BlackBerry { + +namespace WebKit { + +class WebPagePrivate; + +class InPageSearchManager { +public: + InPageSearchManager(WebPagePrivate*); + ~InPageSearchManager(); + + bool findNextString(const String& text, bool forward); + +private: + void clearTextMatches(); + void setMarkerActive(WebCore::Range*, bool active); + + WebPagePrivate* m_webPage; + RefPtr<WebCore::Range> m_activeMatch; + String m_activeSearchString; + int m_activeMatchCount; +}; + +} +} + +#endif // InPageSearchManager_h diff --git a/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.cpp b/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.cpp new file mode 100644 index 000000000..5eac31a30 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "InRegionScrollableArea.h" + +#include "Frame.h" +#include "NotImplemented.h" +#include "RenderBox.h" +#include "RenderLayer.h" +#include "RenderObject.h" +#include "RenderView.h" +#include "WebPage_p.h" + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { + +InRegionScrollableArea::InRegionScrollableArea() + : m_webPage(0) + , m_layer(0) +{ +} + +InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLayer* layer) + : m_webPage(webPage) + , m_layer(layer) +{ + ASSERT(webPage); + ASSERT(layer); + m_isNull = false; + + // FIXME: Add an ASSERT here as the 'layer' must be scrollable. + + RenderObject* layerRenderer = layer->renderer(); + ASSERT(layerRenderer); + + if (layerRenderer->isRenderView()) { // #document case + + FrameView* view = toRenderView(layerRenderer)->frameView(); + ASSERT(view); + + Frame* frame = view->frame(); + ASSERT_UNUSED(frame, frame); + + m_scrollPosition = m_webPage->mapToTransformed(view->scrollPosition()); + m_contentsSize = m_webPage->mapToTransformed(view->contentsSize()); + m_viewportRect = m_webPage->mapToTransformed(view->visibleContentRect(false /*includeScrollbars*/)); + + m_visibleWindowRect = m_webPage->mapToTransformed(m_webPage->getRecursiveVisibleWindowRect(view)); + IntRect transformedWindowRect = IntRect(IntPoint::zero(), m_webPage->transformedViewportSize()); + m_visibleWindowRect.intersect(transformedWindowRect); + + m_scrollsHorizontally = view->contentsWidth() > view->visibleWidth(); + m_scrollsVertically = view->contentsHeight() > view->visibleHeight(); + + m_minimumScrollPosition = m_webPage->mapToTransformed(calculateMinimumScrollPosition( + view->visibleContentRect().size(), + 0.0 /*overscrollLimit*/)); + m_maximumScrollPosition = m_webPage->mapToTransformed(calculateMaximumScrollPosition( + view->visibleContentRect().size(), + view->contentsSize(), + 0.0 /*overscrollLimit*/)); + + } else { // RenderBox-based elements case (scrollable boxes (div's, p's, textarea's, etc)). + + RenderBox* box = m_layer->renderBox(); + ASSERT(box); + ASSERT(box->canBeScrolledAndHasScrollableArea()); + + ScrollableArea* scrollableArea = static_cast<ScrollableArea*>(m_layer); + m_scrollPosition = m_webPage->mapToTransformed(scrollableArea->scrollPosition()); + m_contentsSize = m_webPage->mapToTransformed(scrollableArea->contentsSize()); + m_viewportRect = m_webPage->mapToTransformed(scrollableArea->visibleContentRect(false /*includeScrollbars*/)); + + m_visibleWindowRect = m_layer->renderer()->absoluteClippedOverflowRect(); + m_visibleWindowRect = m_layer->renderer()->frame()->view()->contentsToWindow(m_visibleWindowRect); + IntRect visibleFrameWindowRect = m_webPage->getRecursiveVisibleWindowRect(m_layer->renderer()->frame()->view()); + m_visibleWindowRect.intersect(visibleFrameWindowRect); + m_visibleWindowRect = m_webPage->mapToTransformed(m_visibleWindowRect); + IntRect transformedWindowRect = IntRect(IntPoint::zero(), m_webPage->transformedViewportSize()); + m_visibleWindowRect.intersect(transformedWindowRect); + + m_scrollsHorizontally = box->scrollWidth() != box->clientWidth() && box->scrollsOverflowX(); + m_scrollsVertically = box->scrollHeight() != box->clientHeight() && box->scrollsOverflowY(); + + m_minimumScrollPosition = m_webPage->mapToTransformed(calculateMinimumScrollPosition( + Platform::IntSize(box->clientWidth(), box->clientHeight()), + 0.0 /*overscrollLimit*/)); + m_maximumScrollPosition = m_webPage->mapToTransformed(calculateMaximumScrollPosition( + Platform::IntSize(box->clientWidth(), box->clientHeight()), + Platform::IntSize(box->scrollWidth(), box->scrollHeight()), + 0.0 /*overscrollLimit*/)); + } +} + +Platform::IntPoint InRegionScrollableArea::calculateMinimumScrollPosition(const Platform::IntSize& viewportSize, float overscrollLimitFactor) const +{ + // FIXME: Eventually we should support overscroll like iOS5 does. + ASSERT(!allowsOverscroll()); + + return Platform::IntPoint(-(viewportSize.width() * overscrollLimitFactor), + -(viewportSize.height() * overscrollLimitFactor)); +} + +Platform::IntPoint InRegionScrollableArea::calculateMaximumScrollPosition(const Platform::IntSize& viewportSize, const Platform::IntSize& contentsSize, float overscrollLimitFactor) const +{ + // FIXME: Eventually we should support overscroll like iOS5 does. + ASSERT(!allowsOverscroll()); + + return Platform::IntPoint(std::max(contentsSize.width() - viewportSize.width(), 0) + overscrollLimitFactor, + std::max(contentsSize.height() - viewportSize.height(), 0) + overscrollLimitFactor); +} + +RenderLayer* InRegionScrollableArea::layer() const +{ + ASSERT(!m_isNull); + return m_layer; +} +} + +} diff --git a/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.h b/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.h new file mode 100644 index 000000000..9467b9bc5 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef InRegionScrollableArea_h +#define InRegionScrollableArea_h + +#include <BlackBerryPlatformPrimitives.h> +#include <interaction/ScrollViewBase.h> + +namespace WebCore { +class RenderLayer; +} + +namespace BlackBerry { +namespace WebKit { + +class WebPagePrivate; + +class InRegionScrollableArea : public Platform::ScrollViewBase { +public: + + InRegionScrollableArea(); + InRegionScrollableArea(WebPagePrivate*, WebCore::RenderLayer*); + + WebCore::RenderLayer* layer() const; + +private: + Platform::IntPoint calculateMinimumScrollPosition(const Platform::IntSize& viewportSize, float overscrollLimitFactor) const; + Platform::IntPoint calculateMaximumScrollPosition(const Platform::IntSize& viewportSize, const Platform::IntSize& contentsSize, float overscrollLimitFactor) const; + + WebPagePrivate* m_webPage; + WebCore::RenderLayer* m_layer; +}; + +} +} + +#endif diff --git a/Source/WebKit/blackberry/WebKitSupport/InputHandler.cpp b/Source/WebKit/blackberry/WebKitSupport/InputHandler.cpp index ad555dae7..27b941e6f 100644 --- a/Source/WebKit/blackberry/WebKitSupport/InputHandler.cpp +++ b/Source/WebKit/blackberry/WebKitSupport/InputHandler.cpp @@ -110,11 +110,13 @@ InputHandler::InputHandler(WebPagePrivate* page) : m_webPage(page) , m_currentFocusElement(0) , m_processingChange(false) - , m_navigationMode(false) + , m_changingFocus(false) , m_currentFocusElementType(TextEdit) , m_currentFocusElementTextEditMask(DEFAULT_STYLE) , m_composingTextStart(0) , m_composingTextEnd(0) + , m_pendingKeyboardVisibilityChange(NoChange) + , m_delayKeyboardVisibilityChange(false) { } @@ -223,7 +225,7 @@ BlackBerryInputType InputHandler::elementType(Element* element) const void InputHandler::nodeFocused(Node* node) { if (isActiveTextEdit() && m_currentFocusElement == node) { - setNavigationMode(true); + notifyClientOfKeyboardVisibilityChange(true); return; } @@ -391,10 +393,10 @@ void InputHandler::setElementUnfocused(bool refocusOccuring) // End any composition that is in progress. finishComposition(); - // Send change notifications. Only cancel navigation mode if we are not - // refocusing to avoid flashing the keyboard when switching between two - // input fields. - setNavigationMode(false, !refocusOccuring); + // Only hide the keyboard if we aren't refocusing on a new input field. + if (!refocusOccuring) + notifyClientOfKeyboardVisibilityChange(false); + m_webPage->m_client->inputFocusLost(); m_webPage->m_selectionHandler->selectionPositionChanged(); } @@ -410,29 +412,37 @@ bool InputHandler::shouldAcceptInputFocus() if (m_webPage->m_dumpRenderTree) return true; - if (BlackBerry::Platform::Settings::get()->alwaysShowKeyboardOnFocus()) + if (BlackBerry::Platform::Settings::get()->alwaysShowKeyboardOnFocus()) { + FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::shouldAcceptInputFocus alwaysShowKeyboardOnFocus is active."); return true; + } - Frame* mainFrame = m_webPage->m_page->mainFrame(); Frame* focusedFrame = m_webPage->focusedOrMainFrame(); - if (mainFrame && mainFrame->document() && focusedFrame && focusedFrame->document()) { - // Any user action should be respected. Mouse will be down when touch is - // used to focus. - if (focusedFrame->eventHandler()->mousePressed()) - return true; + if (!focusedFrame) { + FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::shouldAcceptInputFocus Frame not valid."); + return false; + } - // Make sure the main frame is not still loading. - if (mainFrame->loader()->isLoading()) - return false; + // Any user action should be respected. Mouse will be down when touch is + // used to focus. + if (focusedFrame->eventHandler()->mousePressed()) { + FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::shouldAcceptInputFocus Mouse is pressed focusing."); + return true; + } - // Make sure the focused frame is loaded. - if (!focusedFrame->loader()->frameHasLoaded()) - return false; + if (!m_webPage->m_client->hasKeyboardFocus()) { + FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::shouldAcceptInputFocus Client does not have input focus."); + return false; + } - // Make sure the focused frame is not processing load events. - return !focusedFrame->document()->processingLoadEvent(); + if (m_webPage->isLoading()) { + FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::shouldAcceptInputFocus Webpage is loading."); + return false; } - return false; + + // Make sure the focused frame is not processing load events. + FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::shouldAcceptInputFocus returning state of processingLoadEvent (%s).", !focusedFrame->document()->processingLoadEvent() ? "true" : "false"); + return !focusedFrame->document()->processingLoadEvent(); } void InputHandler::setElementFocused(Element* element) @@ -440,9 +450,15 @@ void InputHandler::setElementFocused(Element* element) ASSERT(DOMSupport::isTextBasedContentEditableElement(element)); ASSERT(element->document() && element->document()->frame()); - if (!shouldAcceptInputFocus()) { - // Remove the focus from this element. + if (!m_changingFocus && !shouldAcceptInputFocus()) { + // Remove the focus from this element, but guard against recursion by + // allowing a refocus during the blur to continue. + // THIS IS A HACK that needs to be fixed. Instead of blur the field, + // the frame or frame selection should be blurred. Google bypasses these + // though so it can't be done right now. + m_changingFocus = true; element->blur(); + m_changingFocus = false; return; } @@ -459,8 +475,9 @@ void InputHandler::setElementFocused(Element* element) FocusLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::setElementFocused, Type=%d, Style=%d", type, m_currentFocusElementTextEditMask); - m_webPage->m_client->inputFocusGained(type, m_currentFocusElementTextEditMask); - m_navigationMode = true; + m_webPage->m_client->inputFocusGained(type, + m_currentFocusElementTextEditMask, + m_delayKeyboardVisibilityChange /* wait for explicit keyboard show call */); handleInputLocaleChanged(m_webPage->m_webSettings->isWritingDirectionRTL()); } @@ -528,7 +545,7 @@ void InputHandler::nodeTextChanged(const Node* node) void InputHandler::ensureFocusTextElementVisible(CaretScrollType scrollType) { - if (!m_currentFocusElement || !m_navigationMode || !m_currentFocusElement->document()) + if (!m_currentFocusElement || !m_currentFocusElement->document()) return; if (!BlackBerry::Platform::Settings::get()->allowCenterScrollAdjustmentForInputFields() && scrollType != EdgeIfNeeded) @@ -706,34 +723,36 @@ void InputHandler::frameUnloaded(Frame* frame) setElementUnfocused(false /*refocusOccuring*/); } -void InputHandler::setNavigationMode(bool active, bool sendMessage) +void InputHandler::setDelayKeyboardVisibilityChange(bool value) { - if (active && !isActiveTextEdit()) { - if (!m_navigationMode) - return; + m_delayKeyboardVisibilityChange = value; + m_pendingKeyboardVisibilityChange = NoChange; +} - // We can't be active if there is no element. Send out notification that we - // aren't in navigation mode. - active = false; +void InputHandler::processPendingKeyboardVisibilityChange() +{ + if (!m_delayKeyboardVisibilityChange) { + ASSERT(m_pendingKeyboardVisibilityChange == NoChange); + return; } - // Don't send the change if it's setting the event setting navigationMode true - // if we are already in navigation mode and this is a navigation move event. - // We need to send the event when it's triggered by a touch event or mouse - // event to allow display of the VKB, but do not want to send it when it's - // triggered by a navigation event as it has no effect. - // Touch events are simulated as mouse events so mousePressed will be active - // when it is a re-entry event. - // See RIM Bugs #369 & #878. - if (active && active == m_navigationMode && !m_webPage->m_mainFrame->eventHandler()->mousePressed()) + m_delayKeyboardVisibilityChange = false; + + if (m_pendingKeyboardVisibilityChange == NoChange) return; - m_navigationMode = active; + notifyClientOfKeyboardVisibilityChange(m_pendingKeyboardVisibilityChange == Visible); + m_pendingKeyboardVisibilityChange = NoChange; +} - InputLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::setNavigationMode %s, %s", active ? "true" : "false", sendMessage ? "message sent" : "message not sent"); +void InputHandler::notifyClientOfKeyboardVisibilityChange(bool visible) +{ + if (!m_delayKeyboardVisibilityChange) { + m_webPage->showVirtualKeyboard(visible); + return; + } - if (sendMessage) - m_webPage->m_client->inputSetNavigationMode(active); + m_pendingKeyboardVisibilityChange = visible ? Visible : NotVisible; } bool InputHandler::selectionAtStartOfElement() @@ -856,7 +875,7 @@ WebCore::IntRect InputHandler::rectForCaret(int index) ASSERT(m_currentFocusElement->document() && m_currentFocusElement->document()->frame()); - if (index < 0 || index > elementText().length()) { + if (index < 0 || index > static_cast<int>(elementText().length())) { // Invalid request. return WebCore::IntRect(); } @@ -920,68 +939,6 @@ bool InputHandler::handleKeyboardInput(const BlackBerry::Platform::KeyboardEvent return keyboardEventHandled; } -bool InputHandler::handleNavigationMove(unsigned short character, bool shiftDown, bool altDown, bool canExitField) -{ - InputLog(BlackBerry::Platform::LogLevelInfo, "InputHandler::handleNavigationMove received character=%lc", character); - - bool eventHandled = false; - ASSERT(m_webPage->m_page->focusController()); - if (Frame* focusedFrame = m_webPage->m_page->focusController()->focusedFrame()) { - // If alt is down, do not break out of the field. - if (canExitField && !altDown) { - if ((character == KEYCODE_LEFT || character == KEYCODE_UP) && selectionAtStartOfElement() - || (character == KEYCODE_RIGHT || character == KEYCODE_DOWN) && selectionAtEndOfElement()) { - setNavigationMode(false); - return true; - } - } - - switch (character) { - case KEYCODE_LEFT: - if (altDown && shiftDown) - eventHandled = focusedFrame->editor()->command("MoveToBeginningOfLineAndModifySelection").execute(); - else if (altDown) - eventHandled = focusedFrame->editor()->command("MoveToBeginningOfLine").execute(); - else if (shiftDown) - eventHandled = focusedFrame->editor()->command("MoveLeftAndModifySelection").execute(); - else - eventHandled = focusedFrame->editor()->command("MoveLeft").execute(); - break; - case KEYCODE_RIGHT: - if (altDown && shiftDown) - eventHandled = focusedFrame->editor()->command("MoveToEndOfLineAndModifySelection").execute(); - else if (altDown) - eventHandled = focusedFrame->editor()->command("MoveToEndOfLine").execute(); - else if (shiftDown) - eventHandled = focusedFrame->editor()->command("MoveRightAndModifySelection").execute(); - else - eventHandled = focusedFrame->editor()->command("MoveRight").execute(); - break; - case KEYCODE_UP: - if (altDown && shiftDown) - eventHandled = focusedFrame->editor()->command("MoveToBeginningOfDocumentAndModifySelection").execute(); - else if (altDown) - eventHandled = focusedFrame->editor()->command("MoveToBeginningOfDocument").execute(); - else if (shiftDown) - eventHandled = focusedFrame->editor()->command("MoveUpAndModifySelection").execute(); - else - eventHandled = focusedFrame->editor()->command("MoveUp").execute(); - break; - case KEYCODE_DOWN: - if (altDown && shiftDown) - eventHandled = focusedFrame->editor()->command("MoveToEndOfDocumentAndModifySelection").execute(); - else if (altDown) - eventHandled = focusedFrame->editor()->command("MoveToEndOfDocument").execute(); - else if (shiftDown) - eventHandled = focusedFrame->editor()->command("MoveDownAndModifySelection").execute(); - else - eventHandled = focusedFrame->editor()->command("MoveDown").execute(); - break; - } - } - return eventHandled; -} - bool InputHandler::deleteSelection() { if (!isActiveTextEdit()) diff --git a/Source/WebKit/blackberry/WebKitSupport/InputHandler.h b/Source/WebKit/blackberry/WebKitSupport/InputHandler.h index ba7eb3e7b..1b64a78b1 100644 --- a/Source/WebKit/blackberry/WebKitSupport/InputHandler.h +++ b/Source/WebKit/blackberry/WebKitSupport/InputHandler.h @@ -63,7 +63,6 @@ public: void frameUnloaded(WebCore::Frame*); bool handleKeyboardInput(const BlackBerry::Platform::KeyboardEvent&, bool changeIsPartOfComposition = false); - bool handleNavigationMove(const unsigned short character, bool shiftDown, bool altDown, bool canExitField = true); bool deleteSelection(); void insertText(const WTF::String&); @@ -77,11 +76,14 @@ public: void setInputValue(const WTF::String&); + void setDelayKeyboardVisibilityChange(bool value); + void processPendingKeyboardVisibilityChange(); + + void notifyClientOfKeyboardVisibilityChange(bool visible); + bool isInputMode() const { return isActiveTextEdit(); } bool isMultilineInputMode() const { return isActiveTextEdit() && elementType(m_currentFocusElement.get()) == BlackBerry::Platform::InputTypeTextArea; } - void setNavigationMode(bool active, bool sendMessage = true); - void ensureFocusElementVisible(bool centerFieldInDisplay = true); void handleInputLocaleChanged(bool isRTL); @@ -117,6 +119,8 @@ public: bool shouldAcceptInputFocus(); private: + enum PendingKeyboardStateChange { NoChange, Visible, NotVisible }; + void setElementFocused(WebCore::Element*); void setPluginFocused(WebCore::Element*); void setElementUnfocused(bool refocusOccuring = false); @@ -175,12 +179,16 @@ private: RefPtr<WebCore::Element> m_currentFocusElement; bool m_processingChange; - bool m_navigationMode; + bool m_changingFocus; + FocusElementType m_currentFocusElementType; int m_currentFocusElementTextEditMask; int m_composingTextStart; int m_composingTextEnd; + + PendingKeyboardStateChange m_pendingKeyboardVisibilityChange; + bool m_delayKeyboardVisibilityChange; }; } diff --git a/Source/WebKit/blackberry/WebKitSupport/RenderQueue.cpp b/Source/WebKit/blackberry/WebKitSupport/RenderQueue.cpp new file mode 100644 index 000000000..1f320b9a8 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/RenderQueue.cpp @@ -0,0 +1,910 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "RenderQueue.h" + +#include "BackingStore_p.h" +#include "WebPageClient.h" +#include "WebPage_p.h" + +#define DEBUG_RENDER_QUEUE 0 +#define DEBUG_RENDER_QUEUE_SORT 0 + +#if DEBUG_RENDER_QUEUE +#include <BlackBerryPlatformLog.h> +#include <wtf/CurrentTime.h> +#endif + +namespace BlackBerry { +namespace WebKit { + +template<SortDirection sortDirection> +static inline int compareRectOneDirection(const Platform::IntRect& r1, const Platform::IntRect& r2) +{ + switch (sortDirection) { + case LeftToRight: + return r1.x() - r2.x(); + case RightToLeft: + return r2.x() - r1.x(); + case TopToBottom: + return r1.y() - r2.y(); + case BottomToTop: + return r2.y() - r1.y(); + default: + break; + } + ASSERT_NOT_REACHED(); + return 0; +} + +template<SortDirection primarySortDirection, SortDirection secondarySortDirection> +static bool rectIsLessThan(const Platform::IntRect& r1, const Platform::IntRect& r2) +{ + int primaryResult = compareRectOneDirection<primarySortDirection>(r1, r2); + if (primaryResult || secondarySortDirection == primarySortDirection) + return primaryResult < 0; + return compareRectOneDirection<secondarySortDirection>(r1, r2) < 0; +} + +typedef bool (*FuncRectLessThan)(const Platform::IntRect& r1, const Platform::IntRect& r2); +static FuncRectLessThan rectLessThanFunction(SortDirection primary, SortDirection secondary) +{ + static FuncRectLessThan s_rectLessThanFunctions[NumSortDirections][NumSortDirections] = { { 0 } }; + static bool s_initialized = false; + if (!s_initialized) { +#define ADD_COMPARE_FUNCTION(_primary, _secondary) \ + s_rectLessThanFunctions[_primary][_secondary] = rectIsLessThan<_primary, _secondary> + + ADD_COMPARE_FUNCTION(LeftToRight, LeftToRight); + ADD_COMPARE_FUNCTION(LeftToRight, RightToLeft); + ADD_COMPARE_FUNCTION(LeftToRight, TopToBottom); + ADD_COMPARE_FUNCTION(LeftToRight, BottomToTop); + + ADD_COMPARE_FUNCTION(RightToLeft, LeftToRight); + ADD_COMPARE_FUNCTION(RightToLeft, RightToLeft); + ADD_COMPARE_FUNCTION(RightToLeft, TopToBottom); + ADD_COMPARE_FUNCTION(RightToLeft, BottomToTop); + + ADD_COMPARE_FUNCTION(TopToBottom, LeftToRight); + ADD_COMPARE_FUNCTION(TopToBottom, RightToLeft); + ADD_COMPARE_FUNCTION(TopToBottom, TopToBottom); + ADD_COMPARE_FUNCTION(TopToBottom, BottomToTop); + + ADD_COMPARE_FUNCTION(BottomToTop, LeftToRight); + ADD_COMPARE_FUNCTION(BottomToTop, RightToLeft); + ADD_COMPARE_FUNCTION(BottomToTop, TopToBottom); + ADD_COMPARE_FUNCTION(BottomToTop, BottomToTop); +#undef ADD_COMPARE_FUNCTION + + s_initialized = true; + } + + return s_rectLessThanFunctions[primary][secondary]; +} + +class RectLessThan { +public: + RectLessThan(SortDirection primarySortDirection, SortDirection secondarySortDirection) + : m_rectIsLessThan(rectLessThanFunction(primarySortDirection, secondarySortDirection)) + { + } + + bool operator()(const Platform::IntRect& r1, const Platform::IntRect& r2) + { + return m_rectIsLessThan(r1, r2); + } + +private: + FuncRectLessThan m_rectIsLessThan; +}; + +class RenderRectLessThan { +public: + RenderRectLessThan(SortDirection primarySortDirection, SortDirection secondarySortDirection) + : m_rectIsLessThan(rectLessThanFunction(primarySortDirection, secondarySortDirection)) + { + } + + bool operator()(const RenderRect& r1, const RenderRect& r2) + { + return m_rectIsLessThan(r1.subRects()[0], r2.subRects()[0]); + } + +private: + FuncRectLessThan m_rectIsLessThan; +}; + +RenderRect::RenderRect(const Platform::IntPoint& location, const Platform::IntSize& size, int splittingFactor) + : Platform::IntRect(location, size) + , m_splittingFactor(0) + , m_primarySortDirection(TopToBottom) + , m_secondarySortDirection(LeftToRight) +{ + initialize(splittingFactor); +} + +RenderRect::RenderRect(int x, int y, int width, int height, int splittingFactor) + : Platform::IntRect(x, y, width, height) + , m_splittingFactor(0) + , m_primarySortDirection(TopToBottom) + , m_secondarySortDirection(LeftToRight) +{ + initialize(splittingFactor); +} + +void RenderRect::initialize(int splittingFactor) +{ + m_subRects.push_back(*this); + for (int i = 0; i < splittingFactor; ++i) + split(); + quickSort(); +} + +static void splitRectInHalfAndAddToList(const Platform::IntRect& rect, bool vertical, IntRectList& renderRectList) +{ + if (vertical) { + int width1 = static_cast<int>(ceilf(rect.width() / 2.0)); + int width2 = static_cast<int>(floorf(rect.width() / 2.0)); + renderRectList.push_back(Platform::IntRect(rect.x(), rect.y(), width1, rect.height())); + renderRectList.push_back(Platform::IntRect(rect.x() + width1, rect.y(), width2, rect.height())); + } else { + int height1 = static_cast<int>(ceilf(rect.height() / 2.0)); + int height2 = static_cast<int>(floorf(rect.height() / 2.0)); + renderRectList.push_back(Platform::IntRect(rect.x(), rect.y(), rect.width(), height1)); + renderRectList.push_back(Platform::IntRect(rect.x(), rect.y() + height1, rect.width(), height2)); + } +} + +void RenderRect::split() +{ + ++m_splittingFactor; + + bool vertical = !(m_splittingFactor % 2); + + IntRectList subRects; + for (size_t i = 0; i < m_subRects.size(); ++i) + splitRectInHalfAndAddToList(m_subRects.at(i), vertical, subRects); + m_subRects.swap(subRects); +} + +Platform::IntRect RenderRect::rectForRendering() +{ + ASSERT(!m_subRects.empty()); + Platform::IntRect rect = m_subRects[0]; + m_subRects.erase(m_subRects.begin()); + return rect; +} + +void RenderRect::updateSortDirection(SortDirection primary, SortDirection secondary) +{ + if (primary == m_primarySortDirection && secondary == m_secondarySortDirection) + return; + + m_primarySortDirection = primary; + m_secondarySortDirection = secondary; + + quickSort(); +} + +void RenderRect::quickSort() +{ + std::sort(m_subRects.begin(), m_subRects.begin(), RectLessThan(m_primarySortDirection, m_secondarySortDirection)); +} + +RenderQueue::RenderQueue(BackingStorePrivate* parent) + : m_parent(parent) + , m_rectsAddedToRegularRenderJobsInCurrentCycle(false) + , m_currentRegularRenderJobsBatchUnderPressure(false) + , m_primarySortDirection(TopToBottom) + , m_secondarySortDirection(LeftToRight) +{ +} + +void RenderQueue::reset() +{ + m_rectsAddedToRegularRenderJobsInCurrentCycle = false; + m_currentRegularRenderJobsBatchUnderPressure = false; + m_primarySortDirection = TopToBottom; + m_secondarySortDirection = LeftToRight; + m_visibleZoomJobs.clear(); + m_visibleScrollJobs.clear(); + m_visibleScrollJobsCompleted.clear(); + m_nonVisibleScrollJobs.clear(); + m_nonVisibleScrollJobsCompleted.clear(); + m_regularRenderJobsRegion = Platform::IntRectRegion(); + m_currentRegularRenderJobsBatch.clear(); + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); + m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion(); + m_parent->stopRenderTimer(); + ASSERT(isEmpty()); +} + +int RenderQueue::splittingFactor(const Platform::IntRect& rect) const +{ + // This method is used to split up regular render rect jobs and we want it to + // to be zoom invariant with respect to WebCore. In other words, if WebCore sends + // us a rect of viewport size to invalidate at zoom 1.0 then we split that up + // in the exact same way we would at zoom 2.0. The amount of content that is + // rendered in any one pass should stay fixed with regard to the zoom level. + Platform::IntRect untransformedRect = m_parent->m_webPage->d->mapFromTransformed(rect); + double rectArea = untransformedRect.width() * untransformedRect.height(); + Platform::IntSize defaultMaxLayoutSize = WebPagePrivate::defaultMaxLayoutSize(); + double maxArea = defaultMaxLayoutSize.width() * defaultMaxLayoutSize.height(); + + const unsigned splitFactor = 1 << 0; + double renderRectArea = maxArea / splitFactor; + return ceil(log(rectArea / renderRectArea) / log(2.0)); +} + +RenderRect RenderQueue::convertToRenderRect(const Platform::IntRect& rect) const +{ + return RenderRect(rect.location(), rect.size(), splittingFactor(rect)); +} + +bool RenderQueue::isEmpty(bool shouldPerformRegularRenderJobs) const +{ + return m_visibleZoomJobs.empty() && m_visibleScrollJobs.empty() + && (!shouldPerformRegularRenderJobs || m_currentRegularRenderJobsBatch.empty()) + && (!shouldPerformRegularRenderJobs || m_regularRenderJobsRegion.isEmpty()) + && m_nonVisibleScrollJobs.empty(); +} + +bool RenderQueue::hasCurrentRegularRenderJob() const +{ + return !m_currentRegularRenderJobsBatch.empty() || !m_regularRenderJobsRegion.isEmpty(); +} + +bool RenderQueue::hasCurrentVisibleZoomJob() const +{ + return !m_visibleZoomJobs.empty(); +} + +bool RenderQueue::hasCurrentVisibleScrollJob() const +{ + return !m_visibleScrollJobs.empty(); +} + +bool RenderQueue::isCurrentVisibleScrollJob(const Platform::IntRect& rect) const +{ + return std::find(m_visibleScrollJobs.begin(), m_visibleScrollJobs.end(), rect) != m_visibleScrollJobs.end(); +} + +bool RenderQueue::isCurrentVisibleScrollJobCompleted(const Platform::IntRect& rect) const +{ + return std::find(m_visibleScrollJobsCompleted.begin(), m_visibleScrollJobsCompleted.end(), rect) != m_visibleScrollJobsCompleted.end(); +} + +bool RenderQueue::isCurrentRegularRenderJob(const Platform::IntRect& rect) const +{ + return m_regularRenderJobsRegion.isRectInRegion(rect) == Platform::IntRectRegion::ContainedInRegion + || m_currentRegularRenderJobsBatchRegion.isRectInRegion(rect) == Platform::IntRectRegion::ContainedInRegion; +} + +bool RenderQueue::currentRegularRenderJobBatchUnderPressure() const +{ + return m_currentRegularRenderJobsBatchUnderPressure; +} + +void RenderQueue::setCurrentRegularRenderJobBatchUnderPressure(bool currentRegularRenderJobsBatchUnderPressure) +{ + m_currentRegularRenderJobsBatchUnderPressure = currentRegularRenderJobsBatchUnderPressure; +} + +void RenderQueue::eventQueueCycled() +{ + // Called by the backing store when the event queue has cycled to allow the + // render queue to determine if the regular render jobs are under pressure. + if (m_rectsAddedToRegularRenderJobsInCurrentCycle && m_currentRegularRenderJobsBatchRegion.isEmpty()) + m_currentRegularRenderJobsBatchUnderPressure = true; + m_rectsAddedToRegularRenderJobsInCurrentCycle = false; +} + +void RenderQueue::addToQueue(JobType type, const IntRectList& rectList) +{ + for (size_t i = 0; i < rectList.size(); ++i) + addToQueue(type, rectList.at(i)); +} + +void RenderQueue::addToQueue(JobType type, const Platform::IntRect& rect) +{ + if (type == NonVisibleScroll && std::find(m_visibleScrollJobs.begin(), m_visibleScrollJobs.end(), rect) != m_visibleScrollJobs.end()) + return; // |rect| is in a higher priority queue. + + switch (type) { + case VisibleZoom: + addToScrollZoomQueue(convertToRenderRect(rect), &m_visibleZoomJobs); + return; + case VisibleScroll: + addToScrollZoomQueue(convertToRenderRect(rect), &m_visibleScrollJobs); + return; + case RegularRender: + { + // Flag that we added rects in the current event queue cycle. + m_rectsAddedToRegularRenderJobsInCurrentCycle = true; + + // We try and detect if this newly added rect intersects or is contained in the currently running + // batch of render jobs. If so, then we have to start the batch over since we decompose individual + // rects into subrects and might have already rendered one of them. If the web page's content has + // changed state then this can lead to artifacts. We mark this by noting the batch is now under pressure + // and the backingstore will attempt to clear it at the next available opportunity. + Platform::IntRectRegion::IntersectionState state = m_currentRegularRenderJobsBatchRegion.isRectInRegion(rect); + if (state == Platform::IntRectRegion::ContainedInRegion || state == Platform::IntRectRegion::PartiallyContainedInRegion) { + m_regularRenderJobsRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsRegion, m_currentRegularRenderJobsBatchRegion); + m_currentRegularRenderJobsBatch.clear(); + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); + m_currentRegularRenderJobsBatchUnderPressure = true; + } + addToRegularQueue(rect); + } + return; + case NonVisibleScroll: + addToScrollZoomQueue(convertToRenderRect(rect), &m_nonVisibleScrollJobs); + return; + } + ASSERT_NOT_REACHED(); +} + +void RenderQueue::addToRegularQueue(const Platform::IntRect& rect) +{ +#if DEBUG_RENDER_QUEUE + if (m_regularRenderJobsRegion.isRectInRegion(rect) != Platform::IntRectRegion::ContainedInRegion) { + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::addToRegularQueue %d,%d %dx%d", + rect.x(), rect.y(), rect.width(), rect.height()); + } +#endif + + // Do not let the regular render queue grow past a maximum of 3 disjoint rects. + if (m_regularRenderJobsRegion.numRects() > 2) + m_regularRenderJobsRegion = Platform::unionOfRects(m_regularRenderJobsRegion.extents(), rect); + else + m_regularRenderJobsRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsRegion, rect); + + if (!isEmpty()) + m_parent->startRenderTimer(); // Start the render timer since we could have some stale content here... +} + +void RenderQueue::addToScrollZoomQueue(const RenderRect& rect, RenderRectList* rectList) +{ + if (std::find(rectList->begin(), rectList->end(), rect) != rectList->end()) + return; + +#if DEBUG_RENDER_QUEUE + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::addToScrollZoomQueue %d,%d %dx%d", + rect.x(), rect.y(), rect.width(), rect.height()); +#endif + rectList->push_back(rect); + + if (!isEmpty()) + m_parent->startRenderTimer(); // Start the render timer since we know we could have some checkerboard here... +} + +void RenderQueue::quickSort(RenderRectList* queue) +{ + size_t length = queue->size(); + if (!length) + return; + + for (size_t i = 0; i < length; ++i) + queue->at(i).updateSortDirection(m_primarySortDirection, m_secondarySortDirection); + return std::sort(queue->begin(), queue->end(), RenderRectLessThan(m_primarySortDirection, m_secondarySortDirection)); +} + +void RenderQueue::updateSortDirection(int lastDeltaX, int lastDeltaY) +{ + bool primaryIsHorizontal = abs(lastDeltaX) >= abs(lastDeltaY); + if (primaryIsHorizontal) { + m_primarySortDirection = lastDeltaX <= 0 ? LeftToRight : RightToLeft; + m_secondarySortDirection = lastDeltaY <= 0 ? TopToBottom : BottomToTop; + } else { + m_primarySortDirection = lastDeltaY <= 0 ? TopToBottom : BottomToTop; + m_secondarySortDirection = lastDeltaX <= 0 ? LeftToRight : RightToLeft; + } +} + +void RenderQueue::visibleContentChanged(const Platform::IntRect& visibleContent) +{ + if (m_visibleScrollJobs.empty() && m_nonVisibleScrollJobs.empty()) { + ASSERT(m_visibleScrollJobsCompleted.empty() && m_nonVisibleScrollJobsCompleted.empty()); + return; + } + + // Move visibleScrollJobs to nonVisibleScrollJobs if they do not intersect + // the visible content rect. + for (size_t i = 0; i < m_visibleScrollJobs.size(); ++i) { + RenderRect rect = m_visibleScrollJobs.at(i); + if (!rect.intersects(visibleContent)) { + m_visibleScrollJobs.erase(m_visibleScrollJobs.begin() + i); + addToScrollZoomQueue(rect, &m_nonVisibleScrollJobs); + --i; + } + } + + // Do the same for the completed list. + for (size_t i = 0; i < m_visibleScrollJobsCompleted.size(); ++i) { + RenderRect rect = m_visibleScrollJobsCompleted.at(i); + if (!rect.intersects(visibleContent)) { + m_visibleScrollJobsCompleted.erase(m_visibleScrollJobsCompleted.begin() + i); + addToScrollZoomQueue(rect, &m_nonVisibleScrollJobsCompleted); + --i; + } + } + + // Move nonVisibleScrollJobs to visibleScrollJobs if they do intersect + // the visible content rect. + for (size_t i = 0; i < m_nonVisibleScrollJobs.size(); ++i) { + RenderRect rect = m_nonVisibleScrollJobs.at(i); + if (rect.intersects(visibleContent)) { + m_nonVisibleScrollJobs.erase(m_nonVisibleScrollJobs.begin() + i); + addToScrollZoomQueue(rect, &m_visibleScrollJobs); + --i; + } + } + + // Do the same for the completed list. + for (size_t i = 0; i < m_nonVisibleScrollJobsCompleted.size(); ++i) { + RenderRect rect = m_nonVisibleScrollJobsCompleted.at(i); + if (rect.intersects(visibleContent)) { + m_nonVisibleScrollJobsCompleted.erase(m_nonVisibleScrollJobsCompleted.begin() + i); + addToScrollZoomQueue(rect, &m_visibleScrollJobsCompleted); + --i; + } + } + + if (m_visibleScrollJobs.empty() && !m_visibleScrollJobsCompleted.empty()) + visibleScrollJobsCompleted(false /*shouldBlit*/); + + if (m_nonVisibleScrollJobs.empty() && !m_nonVisibleScrollJobsCompleted.empty()) + nonVisibleScrollJobsCompleted(); + + // We shouldn't be empty because the early return above and the fact that this + // method just shuffles rects from queue to queue hence the total number of + // rects in the various queues should be conserved. + ASSERT(!isEmpty()); +} + +void RenderQueue::clear(const Platform::IntRectRegion& region, bool clearRegularRenderJobs) +{ + IntRectList rects = region.rects(); + for (size_t i = 0; i < rects.size(); ++i) + clear(rects.at(i), clearRegularRenderJobs); +} + +void RenderQueue::clear(const Platform::IntRect& rect, bool clearRegularRenderJobs) +{ + if (m_visibleScrollJobs.empty() && m_nonVisibleScrollJobs.empty()) + ASSERT(m_visibleScrollJobsCompleted.empty() && m_nonVisibleScrollJobsCompleted.empty()); + + // Remove all rects from all queues that are contained by this rect. + for (size_t i = 0; i < m_visibleScrollJobs.size(); ++i) { + if (rect.contains(m_visibleScrollJobs.at(i))) { + m_visibleScrollJobs.erase(m_visibleScrollJobs.begin() + i); + --i; + } + } + + for (size_t i = 0; i < m_visibleScrollJobsCompleted.size(); ++i) { + if (rect.contains(m_visibleScrollJobsCompleted.at(i))) { + m_visibleScrollJobsCompleted.erase(m_visibleScrollJobsCompleted.begin() + i); + --i; + } + } + + for (size_t i = 0; i < m_nonVisibleScrollJobs.size(); ++i) { + if (rect.contains(m_nonVisibleScrollJobs.at(i))) { + m_nonVisibleScrollJobs.erase(m_nonVisibleScrollJobs.begin() + i); + --i; + } + } + + for (size_t i = 0; i < m_nonVisibleScrollJobsCompleted.size(); ++i) { + if (rect.contains(m_nonVisibleScrollJobsCompleted.at(i))) { + m_nonVisibleScrollJobsCompleted.erase(m_nonVisibleScrollJobsCompleted.begin() + i); + --i; + } + } + + // Only clear the regular render jobs if the flag has been set. + if (clearRegularRenderJobs) + this->clearRegularRenderJobs(rect); + + if (m_visibleScrollJobs.empty() && !m_visibleScrollJobsCompleted.empty()) + visibleScrollJobsCompleted(false /*shouldBlit*/); + + if (m_nonVisibleScrollJobs.empty() && !m_nonVisibleScrollJobsCompleted.empty()) + nonVisibleScrollJobsCompleted(); + + if (isEmpty()) + m_parent->stopRenderTimer(); +} + +void RenderQueue::clearRegularRenderJobs(const Platform::IntRect& rect) +{ + for (size_t i = 0; i < m_currentRegularRenderJobsBatch.size(); ++i) { + if (rect.contains(m_currentRegularRenderJobsBatch.at(i))) { + m_currentRegularRenderJobsBatch.erase(m_currentRegularRenderJobsBatch.begin() + i); + --i; + } + } + m_regularRenderJobsRegion = Platform::IntRectRegion::subtractRegions(m_regularRenderJobsRegion, rect); + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion::subtractRegions(m_currentRegularRenderJobsBatchRegion, rect); + m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion::subtractRegions(m_regularRenderJobsNotRenderedRegion, rect); +} + +void RenderQueue::clearVisibleZoom() +{ + m_visibleZoomJobs.clear(); + if (isEmpty()) + m_parent->stopRenderTimer(); +} + +bool RenderQueue::regularRenderJobsPreviouslyAttemptedButNotRendered(const Platform::IntRect& rect) +{ + return m_regularRenderJobsNotRenderedRegion.isRectInRegion(rect) != Platform::IntRectRegion::NotInRegion; +} + +void RenderQueue::render(bool shouldPerformRegularRenderJobs) +{ + // We request a layout here to ensure that we're executing jobs in the correct + // order. If we didn't request a layout here then the jobs below could result + // in a layout and that layout can alter this queue. So request layout if needed + // to ensure that the queues below are in constant state before performing the + // next rendering job. + +#if DEBUG_RENDER_QUEUE + // Start the time measurement. + double time = WTF::currentTime(); +#endif + + m_parent->requestLayoutIfNeeded(); + +#if DEBUG_RENDER_QUEUE + double elapsed = WTF::currentTime() - time; + if (elapsed) + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::render layout elapsed=%f", elapsed); +#endif + + // Empty the queues in a precise order of priority. + if (!m_visibleZoomJobs.empty()) + renderVisibleZoomJob(); + else if (!m_visibleScrollJobs.empty()) + renderVisibleScrollJob(); + else if (shouldPerformRegularRenderJobs && (!m_currentRegularRenderJobsBatch.empty() || !m_regularRenderJobsRegion.isEmpty())) { + if (currentRegularRenderJobBatchUnderPressure()) + renderAllCurrentRegularRenderJobs(); + else + renderRegularRenderJob(); + } else if (!m_nonVisibleScrollJobs.empty()) + renderNonVisibleScrollJob(); + + if (isEmpty()) + m_parent->stopRenderTimer(); +} + +void RenderQueue::renderAllCurrentRegularRenderJobs() +{ +#if DEBUG_RENDER_QUEUE + // Start the time measurement... + double time = WTF::currentTime(); +#endif + + // Request layout first + m_parent->requestLayoutIfNeeded(); + +#if DEBUG_RENDER_QUEUE + double elapsed = WTF::currentTime() - time; + if (elapsed) + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderAllCurrentRegularRenderJobs layout elapsed=%f", elapsed); +#endif + + // The state of render queue may be modified from inside requestLayoutIfNeeded. + // In fact, it can even be emptied entirely! Layout can trigger a call to + // RenderQueue::clear. See PR#101811 for instance. So we should check again here. + if (!hasCurrentRegularRenderJob()) + return; + + // If there is no current batch of jobs, then create one. + if (m_currentRegularRenderJobsBatchRegion.isEmpty()) { + + // Create a current region object from our regular render region. + m_currentRegularRenderJobsBatchRegion = m_regularRenderJobsRegion; + + // Clear this since we're about to render everything. + m_regularRenderJobsRegion = Platform::IntRectRegion(); + } + + Platform::IntRectRegion regionNotRendered; + if (m_parent->shouldSuppressNonVisibleRegularRenderJobs()) { + // Record any part of the region that doesn't intersect the current visible contents rect. + regionNotRendered = Platform::IntRectRegion::subtractRegions(m_currentRegularRenderJobsBatchRegion, m_parent->visibleContentsRect()); + m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsNotRenderedRegion, regionNotRendered); + +#if DEBUG_RENDER_QUEUE + if (!regionNotRendered.isEmpty()) + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderAllCurrentRegularRenderJobs region not completely rendered!"); +#endif + + // Clip to the visible contents so we'll be faster. + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion::intersectRegions(m_currentRegularRenderJobsBatchRegion, m_parent->visibleContentsRect()); + } + + bool rendered = false; + if (!m_currentRegularRenderJobsBatchRegion.isEmpty()) { + std::vector<Platform::IntRect> rectList = m_currentRegularRenderJobsBatchRegion.rects(); + for (size_t i = 0; i < rectList.size(); ++i) + rendered = m_parent->render(rectList.at(i)) ? true : rendered; + } + +#if DEBUG_RENDER_QUEUE + // Stop the time measurement. + elapsed = WTF::currentTime() - time; + Platform::IntRect extents = m_currentRegularRenderJobsBatchRegion.extents(); + int numberOfRects = m_currentRegularRenderJobsBatchRegion.rects().size(); + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderAllCurrentRegularRenderJobs extents=(%d,%d %dx%d) numberOfRects=%d elapsed=%f", + extents.x(), extents.y(), extents.width(), extents.height(), numberOfRects, elapsed); +#endif + + // Clear the region and blit since this batch is now complete. + Platform::IntRect renderedRect = m_currentRegularRenderJobsBatchRegion.extents(); + m_currentRegularRenderJobsBatch.clear(); + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); + m_currentRegularRenderJobsBatchUnderPressure = false; + + // Update the screen only if we're not scrolling or zooming. + if (rendered && !m_parent->isScrollingOrZooming()) { + if (!m_parent->shouldDirectRenderingToWindow()) + m_parent->blitVisibleContents(); + else + m_parent->invalidateWindow(); + m_parent->m_webPage->client()->notifyContentRendered(renderedRect); + } + + if (m_parent->shouldSuppressNonVisibleRegularRenderJobs() && !regionNotRendered.isEmpty()) + m_parent->updateTilesForScrollOrNotRenderedRegion(false /*checkLoading*/); +} + +void RenderQueue::startRegularRenderJobBatchIfNeeded() +{ + if (!m_currentRegularRenderJobsBatch.empty()) + return; + + // Decompose the current regular render job region into render rect pieces. + IntRectList regularRenderJobs = m_regularRenderJobsRegion.rects(); + + // The current batch... + m_currentRegularRenderJobsBatch = regularRenderJobs; + + // Create a region object that will be checked when adding new rects before + // this batch has been completed. + m_currentRegularRenderJobsBatchRegion = m_regularRenderJobsRegion; + + // Clear the former region since it is now part of this batch. + m_regularRenderJobsRegion = Platform::IntRectRegion(); + +#if DEBUG_RENDER_QUEUE + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::startRegularRenderJobBatchIfNeeded batch size is %d!", m_currentRegularRenderJobsBatch.size()); +#endif +} + +void RenderQueue::renderVisibleZoomJob() +{ + ASSERT(m_visibleZoomJobs.size() > 0); + +#if DEBUG_RENDER_QUEUE + // Start the time measurement. + double time = WTF::currentTime(); +#endif + + RenderRect* rect = &m_visibleZoomJobs[0]; + ASSERT(!rect->isCompleted()); + Platform::IntRect subRect = rect->rectForRendering(); + if (rect->isCompleted()) + m_visibleZoomJobs.erase(m_visibleZoomJobs.begin()); + + m_parent->render(subRect); + + // Record that it has now been rendered via a different type of job... + clearRegularRenderJobs(subRect); + +#if DEBUG_RENDER_QUEUE + // Stop the time measurement + double elapsed = WTF::currentTime() - time; + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderVisibleZoomJob rect=(%d,%d %dx%d) elapsed=%f", + subRect.x(), subRect.y(), subRect.width(), subRect.height(), elapsed); +#endif +} + +void RenderQueue::renderVisibleScrollJob() +{ + ASSERT(!m_visibleScrollJobs.empty()); + +#if DEBUG_RENDER_QUEUE || DEBUG_RENDER_QUEUE_SORT + // Start the time measurement. + double time = WTF::currentTime(); +#endif + + quickSort(&m_visibleScrollJobs); + +#if DEBUG_RENDER_QUEUE_SORT + // Stop the time measurement + double elapsed = WTF::currentTime() - time; + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderVisibleScrollJob sort elapsed=%f", elapsed); +#endif + + RenderRect rect = m_visibleScrollJobs[0]; + m_visibleScrollJobs.erase(m_visibleScrollJobs.begin()); + + ASSERT(!rect.isCompleted()); + Platform::IntRect subRect = rect.rectForRendering(); + if (rect.isCompleted()) + m_visibleScrollJobsCompleted.push_back(rect); + else + m_visibleScrollJobs.insert(m_visibleScrollJobs.begin(), rect); + + m_parent->render(subRect); + + // Record that it has now been rendered via a different type of job... + clearRegularRenderJobs(subRect); + +#if DEBUG_RENDER_QUEUE + // Stop the time measurement + double elapsed = WTF::currentTime() - time; + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderVisibleScrollJob rect=(%d,%d %dx%d) elapsed=%f", + subRect.x(), subRect.y(), subRect.width(), subRect.height(), elapsed); +#endif + + if (m_visibleScrollJobs.empty()) + visibleScrollJobsCompleted(true /*shouldBlit*/); +} + +void RenderQueue::renderRegularRenderJob() +{ +#if DEBUG_RENDER_QUEUE + // Start the time measurement. + double time = WTF::currentTime(); +#endif + + ASSERT(!m_currentRegularRenderJobsBatch.empty() || !m_regularRenderJobsRegion.isEmpty()); + + startRegularRenderJobBatchIfNeeded(); + + // Take the first job from the regular render job queue. + Platform::IntRect rect = m_currentRegularRenderJobsBatch[0]; + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion::subtractRegions(m_currentRegularRenderJobsBatchRegion, Platform::IntRectRegion(rect)); + m_currentRegularRenderJobsBatch.erase(m_currentRegularRenderJobsBatch.begin()); + + Platform::IntRectRegion regionNotRendered; + if (m_parent->shouldSuppressNonVisibleRegularRenderJobs()) { + // Record any part of the region that doesn't intersect the current visible tiles rect. + regionNotRendered = Platform::IntRectRegion::subtractRegions(rect, m_parent->visibleContentsRect()); + m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsNotRenderedRegion, regionNotRendered); + +#if DEBUG_RENDER_QUEUE + if (!regionNotRendered.isEmpty()) { + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderRegularRenderJob rect (%d,%d %dx%d) not completely rendered!", + rect.x(), rect.y(), rect.width(), rect.height()); + } +#endif + + // Clip to the visible tiles so we'll be faster. + rect.intersect(m_parent->visibleContentsRect()); + } + + if (!rect.isEmpty()) + m_parent->render(rect); + +#if DEBUG_RENDER_QUEUE + // Stop the time measurement. + double elapsed = WTF::currentTime() - time; + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderRegularRenderJob rect=(%d,%d %dx%d) elapsed=%f", + rect.x(), rect.y(), rect.width(), rect.height(), elapsed); +#endif + + if (m_currentRegularRenderJobsBatch.empty()) { + Platform::IntRect renderedRect = m_currentRegularRenderJobsBatchRegion.extents(); + // Clear the region and the and blit since this batch is now complete. + m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); + m_currentRegularRenderJobsBatchUnderPressure = false; + // Update the screen only if we're not scrolling or zooming. + if (!m_parent->isScrollingOrZooming()) { + if (!m_parent->shouldDirectRenderingToWindow()) + m_parent->blitVisibleContents(); + else + m_parent->invalidateWindow(); + m_parent->m_webPage->client()->notifyContentRendered(renderedRect); + } + } + + // Make sure we didn't alter state of the queues that should have been empty + // before this method was called. + ASSERT(m_visibleScrollJobs.empty()); + + if (m_parent->shouldSuppressNonVisibleRegularRenderJobs() && !regionNotRendered.isEmpty()) + m_parent->updateTilesForScrollOrNotRenderedRegion(false /*checkLoading*/); +} + +void RenderQueue::renderNonVisibleScrollJob() +{ + ASSERT(!m_nonVisibleScrollJobs.empty()); + +#if DEBUG_RENDER_QUEUE || DEBUG_RENDER_QUEUE_SORT + // Start the time measurement. + double time = WTF::currentTime(); +#endif + + quickSort(&m_nonVisibleScrollJobs); + +#if DEBUG_RENDER_QUEUE_SORT + // Stop the time measurement. + double elapsed = WTF::currentTime() - time; + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderNonVisibleScrollJob sort elapsed=%f", elapsed); +#endif + + RenderRect rect = m_nonVisibleScrollJobs[0]; + m_nonVisibleScrollJobs.erase(m_nonVisibleScrollJobs.begin()); + + ASSERT(!rect.isCompleted()); + Platform::IntRect subRect = rect.rectForRendering(); + if (rect.isCompleted()) + m_nonVisibleScrollJobsCompleted.push_back(rect); + else + m_nonVisibleScrollJobs.insert(m_nonVisibleScrollJobs.begin(), rect); + + m_parent->render(subRect); + + // Record that it has now been rendered via a different type of job... + clearRegularRenderJobs(subRect); + + // Make sure we didn't alter state of the queues that should have been empty + // before this method was called. + ASSERT(m_visibleScrollJobs.empty()); + +#if DEBUG_RENDER_QUEUE + // Stop the time measurement. + double elapsed = WTF::currentTime() - time; + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "RenderQueue::renderNonVisibleScrollJob rect=(%d,%d %dx%d) elapsed=%f", + subRect.x(), subRect.y(), subRect.width(), subRect.height(), elapsed); +#endif + + if (m_nonVisibleScrollJobs.empty()) + nonVisibleScrollJobsCompleted(); +} + +void RenderQueue::visibleScrollJobsCompleted(bool shouldBlit) +{ + // Now blit to the screen if we are done and get rid of the completed list! + ASSERT(m_visibleScrollJobs.empty()); + m_visibleScrollJobsCompleted.clear(); + if (shouldBlit && !m_parent->isScrollingOrZooming()) { + if (!m_parent->shouldDirectRenderingToWindow()) + m_parent->blitVisibleContents(); + else + m_parent->invalidateWindow(); + m_parent->m_webPage->client()->notifyContentRendered(m_parent->visibleContentsRect()); + } +} + +void RenderQueue::nonVisibleScrollJobsCompleted() +{ + // Get rid of the completed list! + ASSERT(m_nonVisibleScrollJobs.empty()); + m_nonVisibleScrollJobsCompleted.clear(); +} + +} // namespace WebKit +} // namespace BlackBerry diff --git a/Source/WebKit/blackberry/WebKitSupport/RenderQueue.h b/Source/WebKit/blackberry/WebKitSupport/RenderQueue.h new file mode 100644 index 000000000..3c9639e67 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/RenderQueue.h @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef RenderQueue_h +#define RenderQueue_h + +#include <BlackBerryPlatformIntRectRegion.h> +#include <BlackBerryPlatformPrimitives.h> +#include <vector> + +namespace BlackBerry { +namespace WebKit { + +class BackingStorePrivate; + +typedef std::vector<Platform::IntRect> IntRectList; + +enum SortDirection { + LeftToRight = 0, + RightToLeft, + TopToBottom, + BottomToTop, + NumSortDirections +}; + +class RenderRect : public Platform::IntRect { +public: + RenderRect() { } + RenderRect(const Platform::IntPoint& location, const Platform::IntSize&, int splittingFactor); + RenderRect(int x, int y, int width, int height, int splittingFactor); + RenderRect(const Platform::IntRect&); + + Platform::IntRect rectForRendering(); + + bool isCompleted() const { return !m_subRects.size(); } + + const IntRectList& subRects() const { return m_subRects; } + void updateSortDirection(SortDirection primary, SortDirection secondary); + +private: + void initialize(int splittingFactor); + void split(); + void quickSort(); + int m_splittingFactor; + IntRectList m_subRects; + SortDirection m_primarySortDirection; + SortDirection m_secondarySortDirection; +}; + +typedef std::vector<RenderRect> RenderRectList; + +class RenderQueue { +public: + enum JobType { VisibleZoom, VisibleScroll, RegularRender, NonVisibleScroll }; + RenderQueue(BackingStorePrivate*); + + void reset(); + RenderRect convertToRenderRect(const Platform::IntRect&) const; + + bool isEmpty(bool shouldPerformRegularRenderJobs = true) const; + + bool hasCurrentRegularRenderJob() const; + bool hasCurrentVisibleZoomJob() const; + bool hasCurrentVisibleScrollJob() const; + bool isCurrentVisibleScrollJob(const Platform::IntRect&) const; + bool isCurrentVisibleScrollJobCompleted(const Platform::IntRect&) const; + bool isCurrentRegularRenderJob(const Platform::IntRect&) const; + + bool currentRegularRenderJobBatchUnderPressure() const; + void setCurrentRegularRenderJobBatchUnderPressure(bool); + + void eventQueueCycled(); + + void addToQueue(JobType, const Platform::IntRect&); + void addToQueue(JobType, const IntRectList&); + + void updateSortDirection(int lastDeltaX, int lastDeltaY); + void visibleContentChanged(const Platform::IntRect&); + void clear(const Platform::IntRectRegion&, bool clearRegularRenderJobs); + void clear(const Platform::IntRect&, bool clearRegularRenderJobs); + void clearRegularRenderJobs(const Platform::IntRect&); + void clearVisibleZoom(); + bool regularRenderJobsPreviouslyAttemptedButNotRendered(const Platform::IntRect&); + Platform::IntRectRegion regularRenderJobsNotRenderedRegion() const { return m_regularRenderJobsNotRenderedRegion; } + + void render(bool shouldPerformRegularRenderJobs = true); + void renderAllCurrentRegularRenderJobs(); + +private: + void startRegularRenderJobBatchIfNeeded(); + + // Render an item from the queue. + void renderVisibleZoomJob(); + void renderVisibleScrollJob(); + void renderRegularRenderJob(); + void renderNonVisibleScrollJob(); + + // Methods to handle a completed set of scroll jobs. + void visibleScrollJobsCompleted(bool shouldBlit); + void nonVisibleScrollJobsCompleted(); + + // Internal method to add to the various queues. + void addToRegularQueue(const Platform::IntRect&); + void addToScrollZoomQueue(const RenderRect&, RenderRectList* queue); + void quickSort(RenderRectList*); + + // The splitting factor for render rects. + int splittingFactor(const Platform::IntRect&) const; + + BackingStorePrivate* m_parent; + + // The highest priority queue. + RenderRectList m_visibleZoomJobs; + RenderRectList m_visibleScrollJobs; + RenderRectList m_visibleScrollJobsCompleted; + // The lowest priority queue. + RenderRectList m_nonVisibleScrollJobs; + RenderRectList m_nonVisibleScrollJobsCompleted; + // The regular render jobs are in the middle. + Platform::IntRectRegion m_regularRenderJobsRegion; + IntRectList m_currentRegularRenderJobsBatch; + Platform::IntRectRegion m_currentRegularRenderJobsBatchRegion; + bool m_rectsAddedToRegularRenderJobsInCurrentCycle; + bool m_currentRegularRenderJobsBatchUnderPressure; + + // Holds the region of the page that we attempt to render, but the + // backingstore was not in the right place at the time. This will + // be checked before we try to restore a tile to it's last rendered + // place. + Platform::IntRectRegion m_regularRenderJobsNotRenderedRegion; + + SortDirection m_primarySortDirection; + SortDirection m_secondarySortDirection; +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // RenderQueue_h diff --git a/Source/WebKit/blackberry/WebKitSupport/SelectionHandler.cpp b/Source/WebKit/blackberry/WebKitSupport/SelectionHandler.cpp new file mode 100644 index 000000000..0723c65c8 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/SelectionHandler.cpp @@ -0,0 +1,943 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "SelectionHandler.h" + +#include "DOMSupport.h" +#include "Document.h" +#include "Editor.h" +#include "EditorClient.h" +#include "FatFingers.h" +#include "Frame.h" +#include "FrameSelection.h" +#include "FrameView.h" +#include "HTMLAnchorElement.h" +#include "HTMLAreaElement.h" +#include "HitTestResult.h" +#include "InputHandler.h" +#include "IntRect.h" +#include "Page.h" +#include "RenderPart.h" +#include "TextGranularity.h" +#include "TouchEventHandler.h" +#include "WebPage.h" +#include "WebPageClient.h" +#include "WebPage_p.h" + +#include "htmlediting.h" +#include "visible_units.h" + +#include <BlackBerryPlatformKeyboardEvent.h> + +#include <sys/keycodes.h> + +#define SHOWDEBUG_SELECTIONHANDLER 0 + +#if SHOWDEBUG_SELECTIONHANDLER +#define DEBUG_SELECTION(severity, format, ...) BlackBerry::Platform::logAlways(severity, format, ## __VA_ARGS__) +#else +#define DEBUG_SELECTION(severity, format, ...) +#endif // SHOWDEBUG_SELECTIONHANDLER + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { + +SelectionHandler::SelectionHandler(WebPagePrivate* page) + : m_webPage(page) + , m_selectionActive(false) + , m_caretActive(false) + , m_lastUpdatedEndPointIsValid(false) +{ +} + +SelectionHandler::~SelectionHandler() +{ +} + +void SelectionHandler::cancelSelection() +{ + m_selectionActive = false; + m_lastSelectionRegion = BlackBerry::Platform::IntRectRegion(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::cancelSelection"); + + if (m_webPage->m_inputHandler->isInputMode()) + m_webPage->m_inputHandler->cancelSelection(); + else + m_webPage->focusedOrMainFrame()->selection()->clear(); +} + +WebString SelectionHandler::selectedText() const +{ + return m_webPage->focusedOrMainFrame()->editor()->selectedText(); +} + +void SelectionHandler::getConsolidatedRegionOfTextQuadsForSelection(const VisibleSelection& selection, BlackBerry::Platform::IntRectRegion& region) const +{ + ASSERT(region.isEmpty()); + + if (!selection.isRange()) + return; + + ASSERT(selection.firstRange()); + + Vector<FloatQuad> quadList; + DOMSupport::visibleTextQuads(*(selection.firstRange()), quadList, true /* use selection height */); + + if (!quadList.isEmpty()) { + FrameView* frameView = m_webPage->focusedOrMainFrame()->view(); + + // frameRect is in frame coordinates. + IntRect frameRect(IntPoint(0, 0), frameView->contentsSize()); + + // framePosition is in main frame coordinates. + IntPoint framePosition = m_webPage->frameOffset(m_webPage->focusedOrMainFrame()); + + // The ranges rect list is based on render elements and may include multiple adjacent rects. + // Use BlackBerry::Platform::IntRectRegion to consolidate these rects into bands as well as a container to pass + // to the client. + for (unsigned i = 0; i < quadList.size(); i++) { + IntRect enclosingRect = quadList[i].enclosingBoundingBox(); + enclosingRect.intersect(frameRect); + enclosingRect.move(framePosition.x(), framePosition.y()); + region = unionRegions(region, BlackBerry::Platform::IntRectRegion(enclosingRect)); + } + } +} + +static VisiblePosition visiblePositionForPointIgnoringClipping(const Frame& frame, const IntPoint& framePoint) +{ + // Frame::visiblePositionAtPoint hard-codes ignoreClipping=false in the + // call to hitTestResultAtPoint. This has a bug where some pages (such as + // metafilter) will return the wrong VisiblePosition for points that are + // outside the visible rect. To work around the bug, this is a copy of + // visiblePositionAtPoint which which passes ignoreClipping=true. + // See RIM Bug #4315. + HitTestResult result = frame.eventHandler()->hitTestResultAtPoint(framePoint, true /* allowShadowContent */, true /* ignoreClipping */); + + Node* node = result.innerNode(); + if (!node) + return VisiblePosition(); + + RenderObject* renderer = node->renderer(); + if (!renderer) + return VisiblePosition(); + + VisiblePosition visiblePos = renderer->positionForPoint(result.localPoint()); + if (visiblePos.isNull()) + visiblePos = VisiblePosition(Position(createLegacyEditingPosition(node, 0))); + + return visiblePos; +} + +static unsigned short directionOfPointRelativeToRect(const IntPoint& point, const IntRect& rect, const bool useTopPadding = true, const bool useBottomPadding = true) +{ + ASSERT(!rect.contains(point)); + + // Padding to prevent accidental trigger of up/down when intending to do horizontal movement. + const int verticalPadding = 5; + + // Do height movement check first but add padding. We may be off on both x & y axis and only + // want to move in one direction at a time. + if (point.y() + (useTopPadding ? verticalPadding : 0) < rect.y()) + return KEYCODE_UP; + if (point.y() > rect.maxY() + (useBottomPadding ? verticalPadding : 0)) + return KEYCODE_DOWN; + if (point.x() < rect.location().x()) + return KEYCODE_LEFT; + if (point.x() > rect.maxX()) + return KEYCODE_RIGHT; + + return 0; +} + +bool SelectionHandler::shouldUpdateSelectionOrCaretForPoint(const IntPoint& point, const IntRect& caretRect, bool startCaret) const +{ + ASSERT(m_webPage->m_inputHandler->isInputMode()); + + // If the point isn't valid don't block change as it is not actually changing. + if (point == DOMSupport::InvalidPoint) + return true; + + VisibleSelection currentSelection = m_webPage->focusedOrMainFrame()->selection()->selection(); + + // If the input field is single line or we are on the first or last + // line of a multiline input field only horizontal movement is supported. + bool aboveCaret = point.y() < caretRect.y(); + bool belowCaret = point.y() >= caretRect.maxY(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::shouldUpdateSelectionOrCaretForPoint multiline = %s above = %s below = %s first line = %s last line = %s start = %s \n" + , m_webPage->m_inputHandler->isMultilineInputMode() ? "true" : "false", aboveCaret ? "true" : "false", belowCaret ? "true" : "false" + , inSameLine(currentSelection.visibleStart(), startOfEditableContent(currentSelection.visibleStart())) ? "true" : "false" + , inSameLine(currentSelection.visibleEnd(), endOfEditableContent(currentSelection.visibleEnd())) ? "true" : "false" + , startCaret ? "true" : "false"); + + if (!m_webPage->m_inputHandler->isMultilineInputMode() && (aboveCaret || belowCaret)) + return false; + if (startCaret && inSameLine(currentSelection.visibleStart(), startOfEditableContent(currentSelection.visibleStart())) && aboveCaret) + return false; + if (!startCaret && inSameLine(currentSelection.visibleEnd(), endOfEditableContent(currentSelection.visibleEnd())) && belowCaret) + return false; + + return true; +} + +void SelectionHandler::setCaretPosition(const IntPoint &position) +{ + if (!m_webPage->m_inputHandler->isInputMode()) + return; + + m_caretActive = true; + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::setCaretPosition requested point %d, %d", position.x(), position.y()); + + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + FrameSelection* controller = focusedFrame->selection(); + IntPoint relativePoint = DOMSupport::convertPointToFrame(m_webPage->mainFrame(), focusedFrame, position); + IntRect currentCaretRect = controller->selection().visibleStart().absoluteCaretBounds(); + + if (relativePoint == DOMSupport::InvalidPoint || !shouldUpdateSelectionOrCaretForPoint(relativePoint, currentCaretRect)) { + selectionPositionChanged(); + return; + } + + VisiblePosition visibleCaretPosition(focusedFrame->visiblePositionForPoint(relativePoint)); + + if (!DOMSupport::isPositionInNode(m_webPage->focusedOrMainFrame()->document()->focusedNode(), visibleCaretPosition.deepEquivalent())) { + if (unsigned short character = directionOfPointRelativeToRect(relativePoint, currentCaretRect)) + m_webPage->m_inputHandler->handleKeyboardInput(BlackBerry::Platform::KeyboardEvent(character)); + + selectionPositionChanged(); + return; + } + + VisibleSelection newSelection(visibleCaretPosition); + if (controller->selection() == newSelection) { + selectionPositionChanged(); + return; + } + + controller->setSelection(newSelection); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::setCaretPosition point valid, cursor updated"); +} + +// This function makes sure we are not reducing the selection to a caret selection. +static bool shouldExtendSelectionInDirection(const VisibleSelection& selection, unsigned short character) +{ + FrameSelection tempSelection; + tempSelection.setSelection(selection); + switch (character) { + case KEYCODE_LEFT: + tempSelection.modify(FrameSelection::AlterationExtend, DirectionLeft, CharacterGranularity); + break; + case KEYCODE_RIGHT: + tempSelection.modify(FrameSelection::AlterationExtend, DirectionRight, CharacterGranularity); + break; + case KEYCODE_UP: + tempSelection.modify(FrameSelection::AlterationExtend, DirectionBackward, LineGranularity); + break; + case KEYCODE_DOWN: + tempSelection.modify(FrameSelection::AlterationExtend, DirectionForward, LineGranularity); + break; + default: + break; + } + + if ((character == KEYCODE_LEFT || character == KEYCODE_RIGHT) + && (!inSameLine(selection.visibleStart(), tempSelection.selection().visibleStart()) + || !inSameLine(selection.visibleEnd(), tempSelection.selection().visibleEnd()))) + return false; + + return tempSelection.selection().selectionType() == VisibleSelection::RangeSelection; +} + +static VisiblePosition directionalVisiblePositionAtExtentOfBox(Frame* frame, const IntRect& boundingBox, unsigned short direction, const IntPoint& basePoint) +{ + ASSERT(frame); + + if (!frame) + return VisiblePosition(); + + switch (direction) { + case KEYCODE_LEFT: + // Extend x to start without modifying y. + return frame->visiblePositionForPoint(IntPoint(boundingBox.x(), basePoint.y())); + case KEYCODE_RIGHT: + // Extend x to end without modifying y. + return frame->visiblePositionForPoint(IntPoint(boundingBox.maxX(), basePoint.y())); + case KEYCODE_UP: + // Extend y to top without modifying x. + return frame->visiblePositionForPoint(IntPoint(basePoint.x(), boundingBox.y())); + case KEYCODE_DOWN: + // Extend y to bottom without modifying x. + return frame->visiblePositionForPoint(IntPoint(basePoint.x(), boundingBox.maxY())); + default: + break; + } + + return frame->visiblePositionForPoint(IntPoint(basePoint.x(), basePoint.y())); +} + +static bool pointIsOutsideOfBoundingBoxInDirection(unsigned direction, const IntPoint& selectionPoint, const IntRect& boundingBox) +{ + if ((direction == KEYCODE_LEFT && selectionPoint.x() < boundingBox.x()) + || (direction == KEYCODE_UP && selectionPoint.y() < boundingBox.y()) + || (direction == KEYCODE_RIGHT && selectionPoint.x() > boundingBox.maxX()) + || (direction == KEYCODE_DOWN && selectionPoint.y() > boundingBox.maxY())) + return true; + + return false; +} + +unsigned short SelectionHandler::extendSelectionToFieldBoundary(bool isStartHandle, const IntPoint& selectionPoint, VisibleSelection& newSelection) +{ + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + if (!focusedFrame->document()->focusedNode() || !focusedFrame->document()->focusedNode()->renderer()) + return 0; + + FrameSelection* controller = focusedFrame->selection(); + + IntRect caretRect = isStartHandle ? controller->selection().visibleStart().absoluteCaretBounds() + : controller->selection().visibleEnd().absoluteCaretBounds(); + + IntRect nodeBoundingBox = focusedFrame->document()->focusedNode()->renderer()->absoluteBoundingBoxRect(); + nodeBoundingBox.inflate(-1); + + // Start handle is outside of the field. Treat it as the changed handle and move + // relative to the start caret rect. + unsigned short character = directionOfPointRelativeToRect(selectionPoint, caretRect, isStartHandle /*useTopPadding*/, !isStartHandle /*useBottomPadding*/); + + // Prevent incorrect movement, handles can only extend the selection this way + // to prevent inversion of the handles. + if (isStartHandle && (character == KEYCODE_RIGHT || character == KEYCODE_DOWN) + || !isStartHandle && (character == KEYCODE_LEFT || character == KEYCODE_UP)) + character = 0; + + VisiblePosition newVisiblePosition = isStartHandle ? controller->selection().extent() : controller->selection().base(); + // Extend the selection to the bounds of the box before doing incremental scroll if the point is outside the node. + // Don't extend selection and handle the character at the same time. + if (pointIsOutsideOfBoundingBoxInDirection(character, selectionPoint, nodeBoundingBox)) + newVisiblePosition = directionalVisiblePositionAtExtentOfBox(focusedFrame, nodeBoundingBox, character, selectionPoint); + + if (isStartHandle) + newSelection = VisibleSelection(newVisiblePosition, newSelection.extent(), true /*isDirectional*/); + else + newSelection = VisibleSelection(newSelection.base(), newVisiblePosition, true /*isDirectional*/); + + // If no selection will be changed, return the character to extend using navigation. + if (controller->selection() == newSelection) + return character; + + // Selection has been updated. + return 0; +} + +// Returns true if handled. +bool SelectionHandler::updateOrHandleInputSelection(VisibleSelection& newSelection, const IntPoint& relativeStart + , const IntPoint& relativeEnd) +{ + ASSERT(m_webPage->m_inputHandler->isInputMode()); + + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + Node* focusedNode = focusedFrame->document()->focusedNode(); + if (!focusedNode || !focusedNode->renderer()) + return false; + + FrameSelection* controller = focusedFrame->selection(); + + IntRect currentStartCaretRect = controller->selection().visibleStart().absoluteCaretBounds(); + IntRect currentEndCaretRect = controller->selection().visibleEnd().absoluteCaretBounds(); + + // Check if the handle movement is valid. + if (!shouldUpdateSelectionOrCaretForPoint(relativeStart, currentStartCaretRect, true /* startCaret */) + || !shouldUpdateSelectionOrCaretForPoint(relativeEnd, currentEndCaretRect, false /* startCaret */)) { + selectionPositionChanged(); + return true; + } + + IntRect nodeBoundingBox = focusedNode->renderer()->absoluteBoundingBoxRect(); + + // Only do special handling if one handle is outside of the node. + bool startIsOutsideOfField = relativeStart != DOMSupport::InvalidPoint && !nodeBoundingBox.contains(relativeStart); + bool endIsOutsideOfField = relativeEnd != DOMSupport::InvalidPoint && !nodeBoundingBox.contains(relativeEnd); + if (startIsOutsideOfField && endIsOutsideOfField) + return false; + + unsigned short character = 0; + if (startIsOutsideOfField) { + character = extendSelectionToFieldBoundary(true /* isStartHandle */, relativeStart, newSelection); + if (character) { + // Invert the selection so that the cursor point is at the beginning. + controller->setSelection(VisibleSelection(controller->selection().end(), controller->selection().start())); + } + } else if (endIsOutsideOfField) { + character = extendSelectionToFieldBoundary(false /* isStartHandle */, relativeEnd, newSelection); + if (character) { + // Reset the selection so that the end is the edit point. + controller->setSelection(VisibleSelection(controller->selection().start(), controller->selection().end())); + } + } + + if (!character) + return false; + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::setSelection making selection change attempt using key event %d", character); + + if (shouldExtendSelectionInDirection(controller->selection(), character)) + m_webPage->m_inputHandler->handleKeyboardInput(BlackBerry::Platform::KeyboardEvent(character, BlackBerry::Platform::KeyboardEvent::KeyDown, KEYMOD_SHIFT)); + + // Must send the selectionPositionChanged every time, sometimes this will duplicate but an accepted + // handleNavigationMove may not make an actual selection change. + selectionPositionChanged(); + return true; +} + +IntPoint SelectionHandler::clipPointToFocusNode(const IntPoint& point) +{ + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + FrameSelection* controller = focusedFrame->selection(); + + if (!focusedFrame->document()->focusedNode() || !focusedFrame->document()->focusedNode()->renderer()) + return point; + + IntRect focusedNodeBoundingBox = focusedFrame->document()->focusedNode()->renderer()->absoluteBoundingBoxRect(); + focusedNodeBoundingBox.inflate(-1); + + IntPoint clippedPoint = point; + if (!focusedNodeBoundingBox.contains(clippedPoint)) + clippedPoint = IntPoint( + point.x() < focusedNodeBoundingBox.x() ? focusedNodeBoundingBox.x() : std::min(focusedNodeBoundingBox.maxX(), point.x()), + point.y() < focusedNodeBoundingBox.y() ? focusedNodeBoundingBox.y() : std::min(focusedNodeBoundingBox.maxY(), point.y())); + + return clippedPoint; +} + +void SelectionHandler::setSelection(const IntPoint& start, const IntPoint& end) +{ + m_selectionActive = true; + + ASSERT(m_webPage); + ASSERT(m_webPage->focusedOrMainFrame()); + ASSERT(m_webPage->focusedOrMainFrame()->selection()); + + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + FrameSelection* controller = focusedFrame->selection(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::setSelection adjusted points %d, %d, %d, %d", start.x(), start.y(), end.x(), end.y()); + + // Note that IntPoint(-1, -1) is being our sentinel so far for + // clipped out selection starting or ending location. + bool startIsValid = start != DOMSupport::InvalidPoint; + m_lastUpdatedEndPointIsValid = end != DOMSupport::InvalidPoint; + + // At least one of the locations must be valid. + ASSERT(startIsValid || m_lastUpdatedEndPointIsValid); + + IntPoint relativeStart = start; + IntPoint relativeEnd = end; + + VisibleSelection newSelection(controller->selection()); + + // We need the selection to be ordered base then extent. + if (!controller->selection().isBaseFirst()) + controller->setSelection(VisibleSelection(controller->selection().start(), controller->selection().end())); + + if (startIsValid) { + relativeStart = DOMSupport::convertPointToFrame(m_webPage->mainFrame(), focusedFrame, start); + + // Set the selection with validation. + newSelection.setBase(visiblePositionForPointIgnoringClipping(*focusedFrame, clipPointToFocusNode(relativeStart))); + + // Reset the selection using the existing extent without validation. + newSelection.setWithoutValidation(newSelection.base(), controller->selection().end()); + } + + if (m_lastUpdatedEndPointIsValid) { + relativeEnd = DOMSupport::convertPointToFrame(m_webPage->mainFrame(), focusedFrame, end); + + // Set the selection with validation. + newSelection.setExtent(visiblePositionForPointIgnoringClipping(*focusedFrame, clipPointToFocusNode(relativeEnd))); + + // Reset the selection using the existing base without validation. + newSelection.setWithoutValidation(controller->selection().start(), newSelection.extent()); + } + + if (m_webPage->m_inputHandler->isInputMode()) { + if (updateOrHandleInputSelection(newSelection, relativeStart, relativeEnd)) + return; + } + + if (controller->selection() == newSelection) { + selectionPositionChanged(); + return; + } + + // If the selection size is reduce to less than a character, selection type becomes + // Caret. As long as it is still a range, it's a valid selection. Selection cannot + // be cancelled through this function. + BlackBerry::Platform::IntRectRegion region; + getConsolidatedRegionOfTextQuadsForSelection(newSelection, region); + clipRegionToVisibleContainer(region); + if (!region.isEmpty()) { + // Check if the handles reversed position. + if (m_selectionActive && !newSelection.isBaseFirst()) + m_webPage->m_client->notifySelectionHandlesReversed(); + + controller->setSelection(newSelection); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::setSelection selection points valid, selection updated"); + } else { + // Requested selection results in an empty selection, skip this change. + selectionPositionChanged(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelWarn, "SelectionHandler::setSelection selection points invalid, selection not updated"); + } +} + +// FIXME re-use this in context. Must be updated to include an option to return the href. +// This function should be moved to a new unit file. Names suggetions include DOMQueries +// and NodeTypes. Functions currently in InputHandler.cpp, SelectionHandler.cpp and WebPage.cpp +// can all be moved in. +static Node* enclosingLinkEventParentForNode(Node* node) +{ + if (!node) + return 0; + + Node* linkNode = node->enclosingLinkEventParentOrSelf(); + return linkNode && linkNode->isLink() ? linkNode : 0; +} + +void SelectionHandler::selectAtPoint(const IntPoint& location) +{ + // If point is invalid trigger selection based expansion. + if (location == DOMSupport::InvalidPoint) { + selectObject(WordGranularity); + return; + } + + Node* targetNode; + IntPoint targetPosition; + // FIXME: Factory this get right fat finger code into a helper. + const FatFingersResult lastFatFingersResult = m_webPage->m_touchEventHandler->lastFatFingersResult(); + if (lastFatFingersResult.positionWasAdjusted() && lastFatFingersResult.nodeAsElementIfApplicable()) { + targetNode = lastFatFingersResult.node(FatFingersResult::ShadowContentNotAllowed); + targetPosition = lastFatFingersResult.adjustedPosition(); + } else { + FatFingersResult newFatFingersResult = FatFingers(m_webPage, location, FatFingers::Text).findBestPoint(); + if (!newFatFingersResult.positionWasAdjusted()) + return; + + targetPosition = newFatFingersResult.adjustedPosition(); + targetNode = newFatFingersResult.node(FatFingersResult::ShadowContentNotAllowed); + } + + ASSERT(targetNode); + + // If the node at the point is a link, focus on the entire link, not a word. + if (Node* link = enclosingLinkEventParentForNode(targetNode)) { + selectObject(link); + return; + } + + // selectAtPoint API currently only supports WordGranularity but may be extended in the future. + selectObject(targetPosition, WordGranularity); +} + +static bool expandSelectionToGranularity(Frame* frame, VisibleSelection selection, TextGranularity granularity, bool isInputMode) +{ + ASSERT(frame); + ASSERT(frame->selection()); + + if (!(selection.start().anchorNode() && selection.start().anchorNode()->isTextNode())) + return false; + + if (granularity == WordGranularity) + selection = DOMSupport::visibleSelectionForClosestActualWordStart(selection); + + selection.expandUsingGranularity(granularity); + RefPtr<Range> newRange = selection.toNormalizedRange(); + RefPtr<Range> oldRange = frame->selection()->selection().toNormalizedRange(); + EAffinity affinity = frame->selection()->affinity(); + + if (isInputMode && !frame->editor()->client()->shouldChangeSelectedRange(oldRange.get(), newRange.get(), affinity, false)) + return false; + + return frame->selection()->setSelectedRange(newRange.get(), affinity, true); +} + +void SelectionHandler::selectObject(const IntPoint& location, TextGranularity granularity) +{ + ASSERT(location.x() >= 0 && location.y() >= 0); + ASSERT(m_webPage && m_webPage->focusedOrMainFrame() && m_webPage->focusedOrMainFrame()->selection()); + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::selectObject adjusted points %d, %d", location.x(), location.y()); + + IntPoint relativePoint = DOMSupport::convertPointToFrame(m_webPage->mainFrame(), focusedFrame, location); + VisiblePosition pointLocation(focusedFrame->visiblePositionForPoint(relativePoint)); + VisibleSelection selection = VisibleSelection(pointLocation, pointLocation); + + m_selectionActive = expandSelectionToGranularity(focusedFrame, selection, granularity, m_webPage->m_inputHandler->isInputMode()); +} + +void SelectionHandler::selectObject(TextGranularity granularity) +{ + ASSERT(m_webPage && m_webPage->m_inputHandler); + // Using caret location, must be inside an input field. + if (!m_webPage->m_inputHandler->isInputMode()) + return; + + ASSERT(m_webPage->focusedOrMainFrame() && m_webPage->focusedOrMainFrame()->selection()); + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::selectObject using current selection"); + + // Use the current selection as the selection point. + ASSERT(focusedFrame->selection()->selectionType() != VisibleSelection::NoSelection); + m_selectionActive = expandSelectionToGranularity(focusedFrame, focusedFrame->selection()->selection(), granularity, true /* isInputMode */); +} + +void SelectionHandler::selectObject(Node* node) +{ + if (!node) + return; + + m_selectionActive = true; + + ASSERT(m_webPage && m_webPage->focusedOrMainFrame() && m_webPage->focusedOrMainFrame()->selection()); + Frame* focusedFrame = m_webPage->focusedOrMainFrame(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::selectNode"); + + VisibleSelection selection = VisibleSelection::selectionFromContentsOfNode(node); + focusedFrame->selection()->setSelection(selection); +} + +static TextDirection directionOfEnclosingBlock(FrameSelection* selection) +{ + Node* enclosingBlockNode = enclosingBlock(selection->selection().extent().deprecatedNode()); + if (!enclosingBlockNode) + return LTR; + + if (RenderObject* renderer = enclosingBlockNode->renderer()) + return renderer->style()->direction(); + + return LTR; +} + +// Returns > 0 if p1 is "closer" to referencePoint, < 0 if p2 is "closer", 0 if they are equidistant. +// Because text is usually arranged in horizontal rows, distance is measured along the y-axis, with x-axis used only to break ties. +// If rightGravity is true, the right-most x-coordinate is chosen, otherwise teh left-most coordinate is chosen. +static inline int comparePointsToReferencePoint(const IntPoint& p1, const IntPoint& p2, const IntPoint& referencePoint, bool rightGravity) +{ + int dy1 = abs(referencePoint.y() - p1.y()); + int dy2 = abs(referencePoint.y() - p2.y()); + if (dy1 != dy2) + return dy2 - dy1; + + // Same y-coordinate, choose the farthest right (or left) point. + if (p1.x() == p2.x()) + return 0; + + if (p1.x() > p2.x()) + return rightGravity ? 1 : -1; + + return rightGravity ? -1 : 1; +} + +// NOTE/FIXME: Due to r77286, we are getting off-by-one results in the IntRect class counterpart implementation of the +// methods below. As done in r89803, r77928 and a few others, lets use local method to fix it. +// We should keep our eyes very open on it, since it can affect BackingStore very badly. +static IntPoint minXMinYCorner(const IntRect& rect) { return rect.location(); } // typically topLeft +static IntPoint maxXMinYCorner(const IntRect& rect) { return IntPoint(rect.x() + rect.width() - 1, rect.y()); } // typically topRight +static IntPoint minXMaxYCorner(const IntRect& rect) { return IntPoint(rect.x(), rect.y() + rect.height() - 1); } // typically bottomLeft +static IntPoint maxXMaxYCorner(const IntRect& rect) { return IntPoint(rect.x() + rect.width() - 1, rect.y() + rect.height() - 1); } // typically bottomRight + +// The caret is a one-pixel wide line down either the right or left edge of a +// rect, depending on the text direction. +static inline bool caretIsOnLeft(bool isStartCaret, bool isRTL) +{ + if (isStartCaret) + return !isRTL; + + return isRTL; +} + +static inline IntPoint caretLocationForRect(const IntRect& rect, bool isStartCaret, bool isRTL) +{ + return caretIsOnLeft(isStartCaret, isRTL) ? minXMinYCorner(rect) : maxXMinYCorner(rect); +} + +static inline IntPoint caretComparisonPointForRect(const IntRect& rect, bool isStartCaret, bool isRTL) +{ + if (isStartCaret) + return caretIsOnLeft(isStartCaret, isRTL) ? minXMinYCorner(rect) : maxXMinYCorner(rect); + + return caretIsOnLeft(isStartCaret, isRTL) ? minXMaxYCorner(rect) : maxXMaxYCorner(rect); +} + +static void adjustCaretRects(IntRect& startCaret, bool isStartCaretClippedOut, + IntRect& endCaret, bool isEndCaretClippedOut, + const std::vector<BlackBerry::Platform::IntRect> rectList, + const IntPoint& startReferencePoint, + const IntPoint& endReferencePoint, + bool isRTL) +{ + // startReferencePoint is the best guess at the top left of the selection; endReferencePoint is the best guess at the bottom right. + if (isStartCaretClippedOut) + startCaret.setLocation(DOMSupport::InvalidPoint); + else { + startCaret = rectList[0]; + startCaret.setLocation(caretLocationForRect(startCaret, true, isRTL)); + } + + if (isEndCaretClippedOut) + endCaret.setLocation(DOMSupport::InvalidPoint); + else { + endCaret = rectList[0]; + endCaret.setLocation(caretLocationForRect(endCaret, false, isRTL)); + } + + if (isStartCaretClippedOut && isEndCaretClippedOut) + return; + + // Reset width to 1 as we are strictly interested in caret location. + startCaret.setWidth(1); + endCaret.setWidth(1); + + for (unsigned i = 1; i < rectList.size(); i++) { + IntRect currentRect(rectList[i]); + + // Compare and update the start and end carets with their respective reference points. + if (!isStartCaretClippedOut && comparePointsToReferencePoint( + caretComparisonPointForRect(currentRect, true, isRTL), + caretComparisonPointForRect(startCaret, true, isRTL), + startReferencePoint, isRTL) > 0) { + startCaret.setLocation(caretLocationForRect(currentRect, true, isRTL)); + startCaret.setHeight(currentRect.height()); + } + + if (!isEndCaretClippedOut && comparePointsToReferencePoint( + caretComparisonPointForRect(currentRect, false, isRTL), + caretComparisonPointForRect(endCaret, false, isRTL), + endReferencePoint, !isRTL) > 0) { + endCaret.setLocation(caretLocationForRect(currentRect, false, isRTL)); + endCaret.setHeight(currentRect.height()); + } + } +} + +void SelectionHandler::clipRegionToVisibleContainer(BlackBerry::Platform::IntRectRegion& region) +{ + ASSERT(m_webPage->m_mainFrame && m_webPage->m_mainFrame->view()); + + Frame* frame = m_webPage->focusedOrMainFrame(); + + // Don't allow the region to extend outside of the all its ancestor frames' visible area. + if (frame != m_webPage->mainFrame()) { + IntRect containingContentRect; + containingContentRect = m_webPage->getRecursiveVisibleWindowRect(frame->view(), true /* no clip to main frame window */); + containingContentRect = m_webPage->m_mainFrame->view()->windowToContents(containingContentRect); + region = intersectRegions(BlackBerry::Platform::IntRectRegion(containingContentRect), region); + } + + // Don't allow the region to extend outside of the input field. + if (m_webPage->m_inputHandler->isInputMode() + && frame->document()->focusedNode() + && frame->document()->focusedNode()->renderer()) { + + // Adjust the bounding box to the frame offset. + IntRect boundingBox(frame->document()->focusedNode()->renderer()->absoluteBoundingBoxRect()); + boundingBox = m_webPage->mainFrame()->view()->windowToContents(frame->view()->contentsToWindow(boundingBox)); + + region = intersectRegions(BlackBerry::Platform::IntRectRegion(boundingBox), region); + } +} + +static IntPoint referencePoint(const VisiblePosition& position, const IntRect& boundingRect, const IntPoint& framePosition, bool isStartCaret, bool isRTL) +{ + // If one of the carets is invalid (this happens, for instance, if the + // selection ends in an empty div) fall back to using the corner of the + // entire region (which is already in frame coordinates so doesn't need + // adjusting). + IntRect startCaretBounds(position.absoluteCaretBounds()); + if (startCaretBounds.isEmpty()) + startCaretBounds = boundingRect; + else + startCaretBounds.move(framePosition.x(), framePosition.y()); + + return caretComparisonPointForRect(startCaretBounds, isStartCaret, isRTL); +} + +// Note: This is the only function in SelectionHandler in which the coordinate +// system is not entirely WebKit. +void SelectionHandler::selectionPositionChanged(bool visualChangeOnly) +{ + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::selectionPositionChanged visibleChangeOnly = %s", visualChangeOnly ? "true" : "false"); + + // This method can get called during WebPage shutdown process. + // If that is the case, just bail out since the client is not + // in a safe state of trust to request anything else from it. + if (!m_webPage->m_mainFrame) + return; + + if (m_webPage->m_inputHandler->isInputMode() && m_webPage->m_inputHandler->processingChange()) { + m_webPage->m_client->cancelSelectionVisuals(); + return; + } + + if (m_caretActive || (m_webPage->m_inputHandler->isInputMode() && m_webPage->focusedOrMainFrame()->selection()->isCaret())) { + // This may update the caret to no longer be active. + caretPositionChanged(); + } + + // Enter selection mode if selection type is RangeSelection, and disable selection if + // selection is active and becomes caret selection. + Frame* frame = m_webPage->focusedOrMainFrame(); + IntPoint framePos = m_webPage->frameOffset(frame); + if (m_selectionActive && (m_caretActive || frame->selection()->isNone())) + m_selectionActive = false; + else if (frame->selection()->isRange()) + m_selectionActive = true; + else if (!m_selectionActive) + return; + + IntRect startCaret; + IntRect endCaret; + + // Get the text rects from the selections range. + BlackBerry::Platform::IntRectRegion region; + getConsolidatedRegionOfTextQuadsForSelection(frame->selection()->selection(), region); + + // If there is no change in selected text and the visual rects + // have not changed then don't bother notifying anything. + if (visualChangeOnly && m_lastSelectionRegion.isEqual(region)) + return; + + m_lastSelectionRegion = region; + + if (!region.isEmpty()) { + IntRect unclippedStartCaret; + IntRect unclippedEndCaret; + + bool isRTL = directionOfEnclosingBlock(frame->selection()) == RTL; + + std::vector<BlackBerry::Platform::IntRect> rectList = region.rects(); + + IntPoint startCaretReferencePoint = referencePoint(frame->selection()->selection().visibleStart(), region.extents(), framePos, true /* isStartCaret */, isRTL); + IntPoint endCaretReferencePoint = referencePoint(frame->selection()->selection().visibleEnd(), region.extents(), framePos, false /* isStartCaret */, isRTL); + + adjustCaretRects(unclippedStartCaret, false /* unclipped */, unclippedEndCaret, false /* unclipped */, rectList, startCaretReferencePoint, endCaretReferencePoint, isRTL); + + clipRegionToVisibleContainer(region); + +#if SHOWDEBUG_SELECTIONHANDLER // Don't rely just on DEBUG_SELECTION to avoid loop. + for (unsigned int i = 0; i < rectList.size(); i++) + DEBUG_SELECTION(BlackBerry::Platform::LogLevelCritical, "Rect list - Unmodified #%d, (%d, %d) (%d x %d)", i, rectList[i].x(), rectList[i].y(), rectList[i].width(), rectList[i].height()); + for (unsigned int i = 0; i < region.numRects(); i++) + DEBUG_SELECTION(BlackBerry::Platform::LogLevelCritical, "Rect list - Consolidated #%d, (%d, %d) (%d x %d)", i, region.rects()[i].x(), region.rects()[i].y(), region.rects()[i].width(), region.rects()[i].height()); +#endif + + bool shouldCareAboutPossibleClippedOutSelection = frame != m_webPage->mainFrame() || m_webPage->m_inputHandler->isInputMode(); + + if (!region.isEmpty() || shouldCareAboutPossibleClippedOutSelection) { + // Adjust the handle markers to be at the end of the painted rect. When selecting links + // and other elements that may have a larger visible area than needs to be rendered a gap + // can exist between the handle and overlay region. + + bool shouldClipStartCaret = !region.isRectInRegion(unclippedStartCaret); + bool shouldClipEndCaret = !region.isRectInRegion(unclippedEndCaret); + + // Find the top corner and bottom corner. + std::vector<BlackBerry::Platform::IntRect> clippedRectList = region.rects(); + adjustCaretRects(startCaret, shouldClipStartCaret, endCaret, shouldClipEndCaret, clippedRectList, startCaretReferencePoint, endCaretReferencePoint, isRTL); + + // Translate the caret values as they must be in transformed coordinates. + if (!shouldClipStartCaret) { + startCaret = m_webPage->mapToTransformed(startCaret); + m_webPage->clipToTransformedContentsRect(startCaret); + } + + if (!shouldClipEndCaret) { + endCaret = m_webPage->mapToTransformed(endCaret); + m_webPage->clipToTransformedContentsRect(endCaret); + } + } + } + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::selectionPositionChanged Start Rect=(%d, %d) (%d x %d) End Rect=(%d, %d) (%d x %d)", + startCaret.x(), startCaret.y(), startCaret.width(), startCaret.height(), endCaret.x(), endCaret.y(), endCaret.width(), endCaret.height()); + + + m_webPage->m_client->notifySelectionDetailsChanged(startCaret, endCaret, region); +} + +// NOTE: This function is not in WebKit coordinates. +void SelectionHandler::caretPositionChanged() +{ + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::caretPositionChanged"); + + IntRect caretLocation; + // If the input field is not active, we must be turning off the caret. + if (!m_webPage->m_inputHandler->isInputMode() && m_caretActive) { + m_caretActive = false; + // Send an empty caret change to turn off the caret. + m_webPage->m_client->notifyCaretChanged(caretLocation, m_webPage->m_touchEventHandler->lastFatFingersResult().isTextInput() /* userTouchTriggered */); + return; + } + + ASSERT(m_webPage && m_webPage->focusedOrMainFrame() && m_webPage->focusedOrMainFrame()->selection()); + + // This function should only reach this point if input mode is active. + ASSERT(m_webPage->m_inputHandler->isInputMode()); + + if (m_webPage->focusedOrMainFrame()->selection()->selectionType() == VisibleSelection::CaretSelection) { + IntPoint frameOffset = m_webPage->frameOffset(m_webPage->focusedOrMainFrame()); + + caretLocation = m_webPage->focusedOrMainFrame()->selection()->selection().visibleStart().absoluteCaretBounds(); + caretLocation.move(frameOffset.x(), frameOffset.y()); + + // Clip against the containing frame and node boundaries. + BlackBerry::Platform::IntRectRegion region(caretLocation); + clipRegionToVisibleContainer(region); + caretLocation = region.extents(); + } + + m_caretActive = !caretLocation.isEmpty(); + + DEBUG_SELECTION(BlackBerry::Platform::LogLevelInfo, "SelectionHandler::caretPositionChanged caret Rect %d, %d, %dx%d", + caretLocation.x(), caretLocation.y(), caretLocation.width(), caretLocation.height()); + + caretLocation = m_webPage->mapToTransformed(caretLocation); + m_webPage->clipToTransformedContentsRect(caretLocation); + + m_webPage->m_client->notifyCaretChanged(caretLocation, m_webPage->m_touchEventHandler->lastFatFingersResult().isTextInput() /* userTouchTriggered */); +} + +bool SelectionHandler::selectionContains(const IntPoint& point) +{ + ASSERT(m_webPage && m_webPage->focusedOrMainFrame() && m_webPage->focusedOrMainFrame()->selection()); + return m_webPage->focusedOrMainFrame()->selection()->contains(point); +} + +} +} diff --git a/Source/WebKit/blackberry/WebKitSupport/SelectionHandler.h b/Source/WebKit/blackberry/WebKitSupport/SelectionHandler.h new file mode 100644 index 000000000..8c5fe7637 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/SelectionHandler.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef SelectionHandler_h +#define SelectionHandler_h + +#include "BlackBerryPlatformIntRectRegion.h" +#include "BlackBerryPlatformPrimitives.h" +#include "TextGranularity.h" + +namespace WTF { +class String; +} + +namespace WebCore { +class IntPoint; +class IntRect; +class Node; +class VisiblePosition; +class VisibleSelection; +} + +namespace BlackBerry { + +namespace WebKit { + +class WebPagePrivate; +class WebString; + +class SelectionHandler { +public: + SelectionHandler(WebPagePrivate*); + ~SelectionHandler(); + + bool isSelectionActive() { return m_selectionActive; } + void setSelectionActive(bool active) { m_selectionActive = active; } + + void cancelSelection(); + WebString selectedText() const; + + bool selectionContains(const WebCore::IntPoint&); + + void setSelection(const WebCore::IntPoint& start, const WebCore::IntPoint& end); + void selectAtPoint(const WebCore::IntPoint&); + void selectObject(const WebCore::IntPoint&, WebCore::TextGranularity); + void selectObject(WebCore::TextGranularity); + void selectObject(WebCore::Node*); + + void selectionPositionChanged(bool visualChangeOnly = false); + + void setCaretPosition(const WebCore::IntPoint&); + + bool lastUpdatedEndPointIsValid() const { return m_lastUpdatedEndPointIsValid; } + +private: + void caretPositionChanged(); + void getConsolidatedRegionOfTextQuadsForSelection(const WebCore::VisibleSelection&, BlackBerry::Platform::IntRectRegion&) const; + void clipRegionToVisibleContainer(BlackBerry::Platform::IntRectRegion&); + bool updateOrHandleInputSelection(WebCore::VisibleSelection& newSelection, const WebCore::IntPoint& relativeStart + , const WebCore::IntPoint& relativeEnd); + WebCore::Node* DOMContainerNodeForVisiblePosition(const WebCore::VisiblePosition&) const; + bool shouldUpdateSelectionOrCaretForPoint(const WebCore::IntPoint&, const WebCore::IntRect&, bool startCaret = true) const; + unsigned short extendSelectionToFieldBoundary(bool isStartHandle, const WebCore::IntPoint& selectionPoint, WebCore::VisibleSelection& newSelection); + WebCore::IntPoint clipPointToFocusNode(const WebCore::IntPoint&); + + WebPagePrivate* m_webPage; + + bool m_selectionActive; + bool m_caretActive; + bool m_lastUpdatedEndPointIsValid; + BlackBerry::Platform::IntRectRegion m_lastSelectionRegion; +}; + +} +} + +#endif // SelectionHandler_h diff --git a/Source/WebKit/blackberry/WebKitSupport/SurfacePool.cpp b/Source/WebKit/blackberry/WebKitSupport/SurfacePool.cpp new file mode 100644 index 000000000..2642f39e3 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/SurfacePool.cpp @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "SurfacePool.h" + +#include "PlatformContextSkia.h" + +#if USE(ACCELERATED_COMPOSITING) +#include "BackingStoreCompositingSurface.h" +#endif + +#include <BlackBerryPlatformLog.h> +#include <BlackBerryPlatformMisc.h> +#include <BlackBerryPlatformScreen.h> +#include <BlackBerryPlatformSettings.h> + +#define SHARED_PIXMAP_GROUP "webkit_backingstore_group" + +namespace BlackBerry { +namespace WebKit { + +#if USE(ACCELERATED_COMPOSITING) && ENABLE_COMPOSITING_SURFACE +static PassRefPtr<BackingStoreCompositingSurface> createCompositingSurface() +{ + BlackBerry::Platform::IntSize screenSize = BlackBerry::Platform::Graphics::Screen::size(); + return BackingStoreCompositingSurface::create(screenSize, false /*doubleBuffered*/); +} +#endif + +SurfacePool* SurfacePool::globalSurfacePool() +{ + static SurfacePool* s_instance = 0; + if (!s_instance) + s_instance = new SurfacePool; + return s_instance; +} + +SurfacePool::SurfacePool() + : m_visibleTileBuffer(0) +#if USE(ACCELERATED_COMPOSITING) + , m_compositingSurface(0) +#endif + , m_tileRenderingSurface(0) + , m_backBuffer(0) + , m_initialized(false) + , m_buffersSuspended(false) +{ +} + +void SurfacePool::initialize(const BlackBerry::Platform::IntSize& tileSize) +{ + if (m_initialized) + return; + m_initialized = true; + + const unsigned numberOfTiles = BlackBerry::Platform::Settings::get()->numberOfBackingStoreTiles(); + const unsigned maxNumberOfTiles = BlackBerry::Platform::Settings::get()->maximumNumberOfBackingStoreTilesAcrossProcesses(); + + if (numberOfTiles) { // Only allocate if we actually use a backingstore. + unsigned byteLimit = (maxNumberOfTiles /*pool*/ + 2 /*visible tile buffer, backbuffer*/) * tileSize.width() * tileSize.height() * 4; + bool success = BlackBerry::Platform::Graphics::createPixmapGroup(SHARED_PIXMAP_GROUP, byteLimit); + if (!success) { + BlackBerry::Platform::log(BlackBerry::Platform::LogLevelWarn, + "Shared buffer pool could not be set up, using regular memory allocation instead."); + } + } + + m_tileRenderingSurface = BlackBerry::Platform::Graphics::drawingSurface(); + +#if USE(ACCELERATED_COMPOSITING) && ENABLE_COMPOSITING_SURFACE + m_compositingSurface = createCompositingSurface(); +#endif + + if (!numberOfTiles) + return; // we only use direct rendering when 0 tiles are specified. + + // Create the shared backbuffer. + m_backBuffer = reinterpret_cast<unsigned>(new TileBuffer(tileSize)); + + for (size_t i = 0; i < numberOfTiles; ++i) + m_tilePool.append(BackingStoreTile::create(tileSize, BackingStoreTile::DoubleBuffered)); +} + +PlatformGraphicsContext* SurfacePool::createPlatformGraphicsContext(BlackBerry::Platform::Graphics::Drawable* drawable) const +{ + return new WebCore::PlatformContextSkia(drawable); +} + +PlatformGraphicsContext* SurfacePool::lockTileRenderingSurface() const +{ + if (!m_tileRenderingSurface) + return 0; + + return createPlatformGraphicsContext(BlackBerry::Platform::Graphics::lockBufferDrawable(m_tileRenderingSurface)); +} + +void SurfacePool::releaseTileRenderingSurface(PlatformGraphicsContext* context) const +{ + if (!m_tileRenderingSurface) + return; + + delete context; + BlackBerry::Platform::Graphics::releaseBufferDrawable(m_tileRenderingSurface); +} + +void SurfacePool::initializeVisibleTileBuffer(const BlackBerry::Platform::IntSize& visibleSize) +{ + if (!m_visibleTileBuffer || m_visibleTileBuffer->size() != visibleSize) { + delete m_visibleTileBuffer; + m_visibleTileBuffer = BackingStoreTile::create(visibleSize, BackingStoreTile::SingleBuffered); + } +} + +TileBuffer* SurfacePool::backBuffer() const +{ + ASSERT(m_backBuffer); + return reinterpret_cast<TileBuffer*>(m_backBuffer); +} + +#if USE(ACCELERATED_COMPOSITING) +BackingStoreCompositingSurface* SurfacePool::compositingSurface() const +{ + return m_compositingSurface.get(); +} +#endif + +void SurfacePool::notifyScreenRotated() +{ +#if USE(ACCELERATED_COMPOSITING) && ENABLE_COMPOSITING_SURFACE + // Recreate compositing surface at new screen resolution. + m_compositingSurface = createCompositingSurface(); +#endif +} + +std::string SurfacePool::sharedPixmapGroup() const +{ + return SHARED_PIXMAP_GROUP; +} + +void SurfacePool::createBuffers() +{ + if (!m_initialized || m_tilePool.isEmpty()) + return; + + // Create the tile pool. + for (size_t i = 0; i < m_tilePool.size(); ++i) + BlackBerry::Platform::Graphics::createPixmapBuffer(m_tilePool[i]->frontBuffer()->nativeBuffer()); + + if (m_visibleTileBuffer) + BlackBerry::Platform::Graphics::createPixmapBuffer(m_visibleTileBuffer->frontBuffer()->nativeBuffer()); + + if (backBuffer()) + BlackBerry::Platform::Graphics::createPixmapBuffer(backBuffer()->nativeBuffer()); + + m_buffersSuspended = false; +} + +void SurfacePool::releaseBuffers() +{ + if (!m_initialized || m_tilePool.isEmpty()) + return; + + m_buffersSuspended = true; + + // Release the tile pool. + for (size_t i = 0; i < m_tilePool.size(); ++i) { + m_tilePool[i]->frontBuffer()->clearRenderedRegion(); + BlackBerry::Platform::Graphics::destroyPixmapBuffer(m_tilePool[i]->frontBuffer()->nativeBuffer()); + } + + if (m_visibleTileBuffer) { + m_visibleTileBuffer->frontBuffer()->clearRenderedRegion(); + BlackBerry::Platform::Graphics::destroyPixmapBuffer(m_visibleTileBuffer->frontBuffer()->nativeBuffer()); + } + + if (backBuffer()) { + backBuffer()->clearRenderedRegion(); + BlackBerry::Platform::Graphics::destroyPixmapBuffer(backBuffer()->nativeBuffer()); + } +} + +} +} diff --git a/Source/WebKit/blackberry/WebKitSupport/SurfacePool.h b/Source/WebKit/blackberry/WebKitSupport/SurfacePool.h new file mode 100644 index 000000000..fa88a5d6a --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/SurfacePool.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef SurfacePool_h +#define SurfacePool_h + +#include "BackingStoreTile.h" + +#include "PlatformContextSkia.h" + +#include <BlackBerryPlatformGraphics.h> +#include <BlackBerryPlatformPrimitives.h> +#include <wtf/Vector.h> + +#define ENABLE_COMPOSITING_SURFACE 1 + +namespace BlackBerry { +namespace WebKit { + +class BackingStoreCompositingSurface; + +class SurfacePool { +public: + static SurfacePool* globalSurfacePool(); + + void initialize(const BlackBerry::Platform::IntSize&); + + int isActive() const { return !m_tilePool.isEmpty() && !m_buffersSuspended; } + int isEmpty() const { return m_tilePool.isEmpty(); } + int size() const { return m_tilePool.size(); } + + typedef WTF::Vector<BackingStoreTile*> TileList; + const TileList tileList() const { return m_tilePool; } + + PlatformGraphicsContext* createPlatformGraphicsContext(BlackBerry::Platform::Graphics::Drawable*) const; + PlatformGraphicsContext* lockTileRenderingSurface() const; + void releaseTileRenderingSurface(PlatformGraphicsContext*) const; + BackingStoreTile* visibleTileBuffer() const { return m_visibleTileBuffer; } + + void initializeVisibleTileBuffer(const BlackBerry::Platform::IntSize&); + + // This is a shared back buffer that is used by all the tiles since + // only one tile will be rendering it at a time and we invalidate + // the whole tile every time we render by copying from the front + // buffer those portions that we don't render. This allows us to + // have N+1 tilebuffers rather than N*2 for our double buffered + // backingstore. + TileBuffer* backBuffer() const; + + BackingStoreCompositingSurface* compositingSurface() const; + + void notifyScreenRotated(); + + std::string sharedPixmapGroup() const; + + void releaseBuffers(); + void createBuffers(); + +private: + // This is necessary so BackingStoreTile can atomically swap buffers with m_backBuffer. + friend class BackingStoreTile; + + SurfacePool(); + + TileList m_tilePool; + BackingStoreTile* m_visibleTileBuffer; +#if USE(ACCELERATED_COMPOSITING) + RefPtr<BackingStoreCompositingSurface> m_compositingSurface; +#endif + BlackBerry::Platform::Graphics::Buffer* m_tileRenderingSurface; + unsigned m_backBuffer; + bool m_initialized; // SurfacePool has been set up, with or without buffers. + bool m_buffersSuspended; // Buffer objects exist, but pixel memory has been freed. +}; +} +} + +#endif // SurfacePool_h diff --git a/Source/WebKit/blackberry/WebKitSupport/TileIndex.h b/Source/WebKit/blackberry/WebKitSupport/TileIndex.h new file mode 100644 index 000000000..3149847c9 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/TileIndex.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2009, 2010, 2011 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef TileIndex_h +#define TileIndex_h + +#include <limits> + +namespace BlackBerry { +namespace WebKit { + +class TileIndex { +public: + TileIndex() + : m_i(std::numeric_limits<unsigned int>::max()) + , m_j(std::numeric_limits<unsigned int>::max()) { } + TileIndex(unsigned int i, unsigned int j) + : m_i(i) + , m_j(j) { } + ~TileIndex() { } + + unsigned int i() const { return m_i; } + unsigned int j() const { return m_j; } + void setIndex(unsigned int i, unsigned int j) + { + m_i = i; + m_j = j; + } + +private: + bool m_isValid; + unsigned int m_i; + unsigned int m_j; +}; + +inline bool operator==(const BlackBerry::WebKit::TileIndex& a, const BlackBerry::WebKit::TileIndex& b) +{ + return a.i() == b.i() && a.j() == b.j(); +} + +inline bool operator!=(const BlackBerry::WebKit::TileIndex& a, const BlackBerry::WebKit::TileIndex& b) +{ + return a.i() != b.i() || a.j() != b.j(); +} +} +} + +#endif // TileIndex_h diff --git a/Source/WebKit/blackberry/WebKitSupport/TileIndexHash.h b/Source/WebKit/blackberry/WebKitSupport/TileIndexHash.h new file mode 100644 index 000000000..0d4633b75 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/TileIndexHash.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef TileIndexHash_h +#define TileIndexHash_h + +#include "TileIndex.h" +#include <limits> +#include <wtf/HashMap.h> + +using BlackBerry::WebKit::TileIndex; + +namespace WTF { + +template<> struct IntHash<TileIndex> { + static unsigned hash(const TileIndex& key) { return intHash((static_cast<uint64_t>(key.i()) << 32 | key.j())); } + static bool equal(const TileIndex& a, const TileIndex& b) { return a == b; } + static const bool safeToCompareToEmptyOrDeleted = true; +}; +template<> struct DefaultHash<TileIndex> { + typedef IntHash<TileIndex> Hash; +}; + +template<> struct HashTraits<TileIndex> : GenericHashTraits<TileIndex> { + static const bool emptyValueIsZero = false; + static const bool needsDestruction = false; + static TileIndex emptyValue() { return TileIndex(); } + static void constructDeletedValue(TileIndex& slot) + { + new (&slot) TileIndex(std::numeric_limits<unsigned int>::max() - 1, + std::numeric_limits<unsigned int>::max() - 1); + } + static bool isDeletedValue(const TileIndex& value) + { + return value.i() == (std::numeric_limits<unsigned int>::max() - 1) + && value.j() == (std::numeric_limits<unsigned int>::max() - 1); + } +}; +} // namespace WTF + +#endif // TileIndexHash_h diff --git a/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.cpp b/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.cpp new file mode 100644 index 000000000..cfe559af0 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.cpp @@ -0,0 +1,405 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" +#include "TouchEventHandler.h" + +#include "DOMSupport.h" +#include "Document.h" +#include "DocumentMarkerController.h" +#include "FocusController.h" +#include "Frame.h" +#include "FrameView.h" +#include "HTMLAnchorElement.h" +#include "HTMLAreaElement.h" +#include "HTMLImageElement.h" +#include "HTMLInputElement.h" +#include "HTMLNames.h" +#include "HTMLPlugInElement.h" +#include "InputHandler.h" +#include "IntRect.h" +#include "IntSize.h" +#include "Node.h" +#include "Page.h" +#include "PlatformMouseEvent.h" +#include "PlatformTouchEvent.h" +#include "RenderLayer.h" +#include "RenderTheme.h" +#include "RenderView.h" +#include "RenderedDocumentMarker.h" +#include "SelectionHandler.h" +#include "WebPage_p.h" + +#include <wtf/MathExtras.h> + +using namespace WebCore; +using namespace WTF; + +namespace BlackBerry { +namespace WebKit { + +static bool hasMouseMoveListener(Element* element) +{ + ASSERT(element); + return element->hasEventListeners(eventNames().mousemoveEvent) || element->document()->hasEventListeners(eventNames().mousemoveEvent); +} + +static bool hasTouchListener(Element* element) +{ + ASSERT(element); + return element->hasEventListeners(eventNames().touchstartEvent) + || element->hasEventListeners(eventNames().touchmoveEvent) + || element->hasEventListeners(eventNames().touchcancelEvent) + || element->hasEventListeners(eventNames().touchendEvent); +} + +static bool elementExpectsMouseEvents(Element* element) +{ + // Make sure we are not operating a shadow node here, since the webpages + // aren't able to attach event listeners to shadow content. + ASSERT(element); + while (element->isInShadowTree()) + element = toElement(element->shadowAncestorNode()); + + return hasMouseMoveListener(element) && !hasTouchListener(element); +} + +static bool shouldConvertTouchToMouse(Element* element) +{ + if (!element) + return false; + + // Range element are a special case that require natural mouse events in order to allow + // dragging of the slider handle. + if (element->hasTagName(HTMLNames::inputTag)) { + HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(element); + if (inputElement->isRangeControl()) + return true; + } + + if ((element->hasTagName(HTMLNames::objectTag) || element->hasTagName(HTMLNames::embedTag)) && static_cast<HTMLPlugInElement*>(element)) + return true; + + // Check if the element has a mouse listener and no touch listener. If so, + // the field will require touch events be converted to mouse events to function properly. + if (elementExpectsMouseEvents(element)) + return true; + + return false; +} + +TouchEventHandler::TouchEventHandler(WebPagePrivate* webpage) + : m_webPage(webpage) + , m_didCancelTouch(false) + , m_convertTouchToMouse(false) + , m_existingTouchMode(ProcessedTouchEvents) +{ +} + +TouchEventHandler::~TouchEventHandler() +{ +} + +bool TouchEventHandler::shouldSuppressMouseDownOnTouchDown() const +{ + return m_lastFatFingersResult.isTextInput() || m_webPage->m_inputHandler->isInputMode() || m_webPage->m_selectionHandler->isSelectionActive(); +} + +void TouchEventHandler::touchEventCancel() +{ + m_webPage->m_inputHandler->processPendingKeyboardVisibilityChange(); + + if (!shouldSuppressMouseDownOnTouchDown()) { + // Input elements delay mouse down and do not need to be released on touch cancel. + m_webPage->m_page->focusController()->focusedOrMainFrame()->eventHandler()->setMousePressed(false); + } + m_convertTouchToMouse = false; + m_didCancelTouch = true; + + // If we cancel a single touch event, we need to also clean up any hover + // state we get into by synthetically moving the mouse to the m_fingerPoint. + Element* elementUnderFatFinger = m_lastFatFingersResult.nodeAsElementIfApplicable(); + if (elementUnderFatFinger && elementUnderFatFinger->renderer()) { + + HitTestRequest request(HitTestRequest::FingerUp); + // The HitTestResult point is not actually needed. + HitTestResult result(IntPoint::zero()); + result.setInnerNode(elementUnderFatFinger); + + Document* document = elementUnderFatFinger->document(); + ASSERT(document); + document->renderView()->layer()->updateHoverActiveState(request, result); + document->updateStyleIfNeeded(); + // Updating the document style may destroy the renderer. + if (elementUnderFatFinger->renderer()) + elementUnderFatFinger->renderer()->repaint(); + ASSERT(!elementUnderFatFinger->hovered()); + } + + m_lastFatFingersResult.reset(); +} + +void TouchEventHandler::touchEventCancelAndClearFocusedNode() +{ + touchEventCancel(); + m_webPage->clearFocusNode(); +} + +void TouchEventHandler::touchHoldEvent() +{ + // This is a hack for our hack that converts the touch pressed event that we've delayed because the user has focused a input field + // to the page as a mouse pressed event. + if (shouldSuppressMouseDownOnTouchDown()) + handleFatFingerPressed(); + + // Clear the focus ring indication if tap-and-hold'ing on a link. + if (m_lastFatFingersResult.node() && m_lastFatFingersResult.node()->isLink()) + m_webPage->clearFocusNode(); +} + +bool TouchEventHandler::handleTouchPoint(Platform::TouchPoint& point) +{ + switch (point.m_state) { + case Platform::TouchPoint::TouchPressed: + { + m_lastFatFingersResult.reset(); // Theoretically this shouldn't be required. Keep it just in case states get mangled. + m_didCancelTouch = false; + m_lastScreenPoint = point.m_screenPos; + + IntPoint contentPos(m_webPage->mapFromViewportToContents(point.m_pos)); + + m_lastFatFingersResult = FatFingers(m_webPage, contentPos, FatFingers::ClickableElement).findBestPoint(); + + Element* elementUnderFatFinger = 0; + if (m_lastFatFingersResult.positionWasAdjusted() && m_lastFatFingersResult.node()) { + ASSERT(m_lastFatFingersResult.node()->isElementNode()); + elementUnderFatFinger = m_lastFatFingersResult.nodeAsElementIfApplicable(); + } + + // Set or reset the touch mode. + Element* possibleTargetNodeForMouseMoveEvents = static_cast<Element*>(m_lastFatFingersResult.positionWasAdjusted() ? elementUnderFatFinger : m_lastFatFingersResult.node()); + m_convertTouchToMouse = shouldConvertTouchToMouse(possibleTargetNodeForMouseMoveEvents); + + if (elementUnderFatFinger) + drawTapHighlight(); + + // Lets be conservative here: since we have problems on major website having + // mousemove listener for no good reason (e.g. google.com, desktop edition), + // let only delay client notifications when there is not input text node involved. + if (m_convertTouchToMouse + && (m_webPage->m_inputHandler->isInputMode() && !m_lastFatFingersResult.isTextInput())) { + m_webPage->m_inputHandler->setDelayKeyboardVisibilityChange(true); + handleFatFingerPressed(); + } else if (!shouldSuppressMouseDownOnTouchDown()) + handleFatFingerPressed(); + + return true; + } + case Platform::TouchPoint::TouchReleased: + { + // Apply any suppressed changes. This does not eliminate the need + // for the show after the handling of fat finger pressed as it may + // have triggered a state change. + m_webPage->m_inputHandler->processPendingKeyboardVisibilityChange(); + + if (shouldSuppressMouseDownOnTouchDown()) + handleFatFingerPressed(); + + // The rebase has eliminated a necessary event when the mouse does not + // trigger an actual selection change preventing re-showing of the + // keyboard. If input mode is active, call showVirtualKeyboard which + // will update the state and display keyboard if needed. + if (m_webPage->m_inputHandler->isInputMode()) + m_webPage->m_inputHandler->notifyClientOfKeyboardVisibilityChange(true); + + IntPoint adjustedPoint; + if (m_convertTouchToMouse) { + adjustedPoint = point.m_pos; + m_convertTouchToMouse = false; + } else // Fat finger point in viewport coordinates. + adjustedPoint = m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition()); + + PlatformMouseEvent mouseEvent(adjustedPoint, m_lastScreenPoint, MouseEventReleased, 1, LeftButton, TouchScreen); + m_webPage->handleMouseEvent(mouseEvent); + m_lastFatFingersResult.reset(); // Reset the fat finger result as its no longer valid when a user's finger is not on the screen. + + unsigned spellLength = spellCheck(point); + if (spellLength) { + unsigned end = m_webPage->m_inputHandler->caretPosition(); + unsigned start = end - spellLength; + m_webPage->m_client->requestSpellingSuggestionsForString(start, end); + } + return true; + } + case Platform::TouchPoint::TouchMoved: + if (m_convertTouchToMouse) { + PlatformMouseEvent mouseEvent(point.m_pos, m_lastScreenPoint, MouseEventMoved, 1, LeftButton, TouchScreen); + m_lastScreenPoint = point.m_screenPos; + if (!m_webPage->handleMouseEvent(mouseEvent)) { + m_convertTouchToMouse = false; + return false; + } + return true; + } + break; + default: + break; + } + return false; +} + +unsigned TouchEventHandler::spellCheck(Platform::TouchPoint& touchPoint) +{ + Element* elementUnderFatFinger = m_lastFatFingersResult.nodeAsElementIfApplicable(); + if (!m_lastFatFingersResult.isTextInput() || !elementUnderFatFinger) + return 0; + + IntPoint contentPos(m_webPage->mapFromViewportToContents(touchPoint.m_pos)); + contentPos = DOMSupport::convertPointToFrame(m_webPage->mainFrame(), m_webPage->focusedOrMainFrame(), contentPos); + + Document* document = elementUnderFatFinger->document(); + ASSERT(document); + RenderedDocumentMarker* marker = document->markers()->renderedMarkerContainingPoint(contentPos, DocumentMarker::Spelling); + if (!marker) + return 0; + + IntRect rect = marker->renderedRect(); + IntPoint newContentPos = IntPoint(rect.x() + rect.width(), rect.y() + rect.height() / 2); + Frame* frame = m_webPage->focusedOrMainFrame(); + if (frame != m_webPage->mainFrame()) + newContentPos = m_webPage->mainFrame()->view()->windowToContents(frame->view()->contentsToWindow(newContentPos)); + m_lastFatFingersResult.m_adjustedPosition = newContentPos; + m_lastFatFingersResult.m_positionWasAdjusted = true; + return marker->endOffset() - marker->startOffset(); +} + +void TouchEventHandler::handleFatFingerPressed() +{ + if (!m_didCancelTouch) { + + // First update the mouse position with a MouseMoved event. + PlatformMouseEvent mouseMoveEvent(m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition()), m_lastScreenPoint, MouseEventMoved, 0, LeftButton, TouchScreen); + m_webPage->handleMouseEvent(mouseMoveEvent); + + // Then send the MousePressed event. + PlatformMouseEvent mousePressedEvent(m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition()), m_lastScreenPoint, MouseEventPressed, 1, LeftButton, TouchScreen); + m_webPage->handleMouseEvent(mousePressedEvent); + } +} + +// This method filters what element will get tap-highlight'ed or not. To start with, +// we are going to highlight links (anchors with a valid href element), and elements +// whose tap highlight color value is different than the default value. +static Element* elementForTapHighlight(Element* elementUnderFatFinger) +{ + // Do not bail out right way here if there element does not have a renderer. + // It is the casefor <map> (descendent of <area>) elements. The associated <image> + // element actually has the renderer. + if (elementUnderFatFinger->renderer()) { + Color tapHighlightColor = elementUnderFatFinger->renderStyle()->tapHighlightColor(); + if (tapHighlightColor != RenderTheme::defaultTheme()->platformTapHighlightColor()) + return elementUnderFatFinger; + } + + bool isArea = elementUnderFatFinger->hasTagName(HTMLNames::areaTag); + Node* linkNode = elementUnderFatFinger->enclosingLinkEventParentOrSelf(); + if (!linkNode || !linkNode->isHTMLElement() || (!linkNode->renderer() && !isArea)) + return 0; + + ASSERT(linkNode->isLink()); + + // FatFingers class selector ensure only anchor with valid href attr value get here. + // It includes empty hrefs. + Element* highlightCandidateElement = static_cast<Element*>(linkNode); + + if (!isArea) + return highlightCandidateElement; + + HTMLAreaElement* area = static_cast<HTMLAreaElement*>(highlightCandidateElement); + HTMLImageElement* image = area->imageElement(); + if (image && image->renderer()) + return image; + + return 0; +} + +void TouchEventHandler::drawTapHighlight() +{ + Element* elementUnderFatFinger = m_lastFatFingersResult.nodeAsElementIfApplicable(); + if (!elementUnderFatFinger) + return; + + Element* element = elementForTapHighlight(elementUnderFatFinger); + if (!element) + return; + + // Get the element bounding rect in transformed coordinates so we can extract + // the focus ring relative position each rect. + RenderObject* renderer = element->renderer(); + ASSERT(renderer); + + Frame* elementFrame = element->document()->frame(); + ASSERT(elementFrame); + + FrameView* elementFrameView = elementFrame->view(); + if (!elementFrameView) + return; + + // Tell the client if the element is either in a scrollable container or in a fixed positioned container. + // On the client side, this info is being used to hide the tap highlight window on scroll. + RenderLayer* layer = m_webPage->enclosingFixedPositionedAncestorOrSelfIfFixedPositioned(renderer->enclosingLayer()); + bool shouldHideTapHighlightRightAfterScrolling = !layer->renderer()->isRenderView(); + shouldHideTapHighlightRightAfterScrolling |= !!m_webPage->m_inRegionScrollStartingNode.get(); + + IntPoint framePos(m_webPage->frameOffset(elementFrame)); + + // FIXME: We can get more precise on the <map> case by calculating the rect with HTMLAreaElement::computeRect(). + IntRect absoluteRect = renderer->absoluteClippedOverflowRect(); + absoluteRect.move(framePos.x(), framePos.y()); + + IntRect clippingRect; + if (elementFrame == m_webPage->mainFrame()) + clippingRect = IntRect(IntPoint(0, 0), elementFrameView->contentsSize()); + else + clippingRect = m_webPage->mainFrame()->view()->windowToContents(m_webPage->getRecursiveVisibleWindowRect(elementFrameView, true /*noClipToMainFrame*/)); + clippingRect = intersection(absoluteRect, clippingRect); + + Vector<FloatQuad> focusRingQuads; + renderer->absoluteFocusRingQuads(focusRingQuads); + + Platform::IntRectRegion region; + for (size_t i = 0; i < focusRingQuads.size(); ++i) { + IntRect rect = focusRingQuads[i].enclosingBoundingBox(); + rect.move(framePos.x(), framePos.y()); + IntRect clippedRect = intersection(clippingRect, rect); + clippedRect.inflate(2); + region = unionRegions(region, Platform::IntRect(clippedRect)); + } + + Color highlightColor = element->renderStyle()->tapHighlightColor(); + + m_webPage->m_client->drawTapHighlight(region, + highlightColor.red(), + highlightColor.green(), + highlightColor.blue(), + highlightColor.alpha(), + shouldHideTapHighlightRightAfterScrolling); +} + +} +} diff --git a/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.h b/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.h new file mode 100644 index 000000000..473fc30a2 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef TouchEventHandler_h +#define TouchEventHandler_h + +#include "ChromeClient.h" +#include "FatFingers.h" +#include "IntPoint.h" + +#include <BlackBerryPlatformTouchEvent.h> +#include <BlackBerryPlatformWindow.h> + +namespace BlackBerry { +namespace WebKit { + +class WebPagePrivate; + +class TouchEventHandler { +public: + TouchEventHandler(WebPagePrivate* webpage); + ~TouchEventHandler(); + + bool handleTouchPoint(Platform::TouchPoint&); + void touchEventCancel(); + void touchEventCancelAndClearFocusedNode(); + void touchHoldEvent(); + + bool shouldSuppressMouseDownOnTouchDown() const; + + const FatFingersResult& lastFatFingersResult() const { return m_lastFatFingersResult; } + void resetLastFatFingersResult() { m_lastFatFingersResult.reset(); } + +private: + unsigned spellCheck(Platform::TouchPoint&); + void handleFatFingerPressed(); + + void drawTapHighlight(); + +private: + WebPagePrivate* m_webPage; + + bool m_didCancelTouch; + bool m_convertTouchToMouse; + + WebCore::TouchEventMode m_existingTouchMode; + + WebCore::IntPoint m_lastScreenPoint; // Screen Position + + FatFingersResult m_lastFatFingersResult; +}; + +} +} + +#endif // TouchEventHandler_h diff --git a/Source/WebKit/blackberry/WebKitSupport/WebPageCompositor.cpp b/Source/WebKit/blackberry/WebKitSupport/WebPageCompositor.cpp new file mode 100644 index 000000000..fcbc1acff --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/WebPageCompositor.cpp @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "config.h" + +#if USE(ACCELERATED_COMPOSITING) +#include "WebPageCompositor.h" + +#include "LayerWebKitThread.h" +#include "WebPage_p.h" + +#include <GenericTimerClient.h> +#include <ThreadTimerClient.h> + +using namespace WebCore; + +namespace BlackBerry { +namespace WebKit { + +WebPageCompositor::WebPageCompositor(WebPagePrivate* page) + : m_webPage(page) + , m_layerRenderer(LayerRenderer::create(page->m_page)) + , m_generation(0) + , m_compositedGeneration(-1) + , m_compositingOntoMainWindow(false) + , m_blitTimer(this, &BlackBerry::WebKit::WebPageCompositor::blitTimerFired) + , m_timerClient(new BlackBerry::Platform::GenericTimerClient(BlackBerry::Platform::userInterfaceThreadTimerClient())) +{ + m_blitTimer.setClient(m_timerClient); +} + +WebPageCompositor::~WebPageCompositor() +{ + m_blitTimer.stop(); + delete m_timerClient; +} + +bool WebPageCompositor::hardwareCompositing() const +{ + return m_layerRenderer->hardwareCompositing(); +} + +void WebPageCompositor::setRootLayer(LayerCompositingThread* rootLayer) +{ + m_rootLayer = rootLayer; + m_layerRenderer->setRootLayer(m_rootLayer.get()); +} + +void WebPageCompositor::setCompositingOntoMainWindow(bool compositingOntoMainWindow) +{ + m_compositingOntoMainWindow = compositingOntoMainWindow; + m_layerRenderer->setClearSurfaceOnDrawLayers(!compositingOntoMainWindow); +} + +void WebPageCompositor::commit(LayerWebKitThread* rootLayer) +{ + if (!rootLayer) + return; + + rootLayer->commitOnCompositingThread(); + ++m_generation; +} + +bool WebPageCompositor::drawLayers(const IntRect& dstRect, const FloatRect& contents) +{ + // Save a draw if we already drew this generation, for example due to a concurrent scroll operation. + if (m_compositedGeneration == m_generation && dstRect == m_compositedDstRect + && contents == m_compositedContentsRect && !m_compositingOntoMainWindow) + return false; + + m_layerRenderer->drawLayers(contents, m_layoutRectForCompositing, m_contentsSizeForCompositing, dstRect); + m_lastCompositingResults = m_layerRenderer->lastRenderingResults(); + + m_compositedDstRect = dstRect; + m_compositedContentsRect = contents; + m_compositedGeneration = m_generation; + + if (m_lastCompositingResults.needsAnimationFrame) { + ++m_generation; // The animation update moves us along one generation. + // Using a timeout of 0 actually won't start a timer, it will send a message. + m_blitTimer.start(1.0 / 60.0); + m_webPage->updateDelegatedOverlays(); + } + + return true; +} + +void WebPageCompositor::releaseLayerResources() +{ + m_layerRenderer->releaseLayerResources(); +} + +void WebPageCompositor::blitTimerFired() +{ + m_webPage->blitVisibleContents(); +} + +} // namespace WebKit +} // namespace BlackBerry + +#endif // USE(ACCELERATED_COMPOSITING) diff --git a/Source/WebKit/blackberry/WebKitSupport/WebPageCompositor.h b/Source/WebKit/blackberry/WebKitSupport/WebPageCompositor.h new file mode 100644 index 000000000..437ab95e0 --- /dev/null +++ b/Source/WebKit/blackberry/WebKitSupport/WebPageCompositor.h @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef WebPageCompositor_h +#define WebPageCompositor_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerCompositingThread.h" +#include "LayerRenderer.h" + +#include <BlackBerryPlatformTimer.h> +#include <wtf/OwnPtr.h> +#include <wtf/RefPtr.h> + +namespace WebCore { +class LayerWebKitThread; +}; + +namespace BlackBerry { +namespace WebKit { + +class WebPagePrivate; + +// This class may only be used on the compositing thread. +class WebPageCompositor { +public: + WebPageCompositor(WebPagePrivate*); + ~WebPageCompositor(); + + bool hardwareCompositing() const; + + void setRootLayer(WebCore::LayerCompositingThread*); + + void setCompositingOntoMainWindow(bool); + + void commit(WebCore::LayerWebKitThread* rootLayerProxy); + + bool drawLayers(const WebCore::IntRect& dstRect, const WebCore::FloatRect& contents); + + WebCore::IntRect layoutRectForCompositing() const { return m_layoutRectForCompositing; } + void setLayoutRectForCompositing(const WebCore::IntRect& rect) { m_layoutRectForCompositing = rect; } + + WebCore::IntSize contentsSizeForCompositing() const { return m_contentsSizeForCompositing; } + void setContentsSizeForCompositing(const WebCore::IntSize& size) { m_contentsSizeForCompositing = size; } + + WebCore::LayerRenderingResults lastCompositingResults() const { return m_lastCompositingResults; } + void setLastCompositingResults(const WebCore::LayerRenderingResults& results) { m_lastCompositingResults = results; } + + void releaseLayerResources(); + +private: + void blitTimerFired(); + + WebPagePrivate* m_webPage; + OwnPtr<WebCore::LayerRenderer> m_layerRenderer; + RefPtr<WebCore::LayerCompositingThread> m_rootLayer; + WebCore::IntRect m_layoutRectForCompositing; + WebCore::IntSize m_contentsSizeForCompositing; + WebCore::LayerRenderingResults m_lastCompositingResults; + int m_generation; + int m_compositedGeneration; + WebCore::IntRect m_compositedDstRect; + WebCore::FloatRect m_compositedContentsRect; + bool m_compositingOntoMainWindow; + BlackBerry::Platform::Timer<WebPageCompositor> m_blitTimer; + BlackBerry::Platform::TimerClient* m_timerClient; +}; + +} // namespace WebKit +} // namespace BlackBerry + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif // WebPageCompositor_h diff --git a/Source/WebKit/chromium/ChangeLog b/Source/WebKit/chromium/ChangeLog index c3837d1cf..797b31c6c 100644 --- a/Source/WebKit/chromium/ChangeLog +++ b/Source/WebKit/chromium/ChangeLog @@ -1,3 +1,1562 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * src/EditorClientImpl.cpp: + (WebKit::EditorClientImpl::requestCheckingOfString): + * src/EditorClientImpl.h: + (EditorClientImpl): + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::requestTextChecking): + +2012-02-23 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed. Rolled DEPS. + + * DEPS: + +2012-02-23 Ian Vollick <vollick@chromium.org> + + [chromium] Implement keyframed animations for the cc thread. + https://bugs.webkit.org/show_bug.cgi?id=77229 + + Reviewed by James Robinson. + + * WebKit.gypi: + * tests/CCAnimationTestCommon.cpp: + (WebCore): + (WebCore::addOpacityTransition): + (WebKitTests::addOpacityTransitionToController): + (WebKitTests::addOpacityTransitionToLayer): + * tests/CCAnimationTestCommon.h: + (WebCore): + (WebKitTests): + * tests/CCKeyframedAnimationCurveTest.cpp: Added. + (WebCore): + (WebCore::expectTranslateX): + (WebCore::TEST): + * tests/CCLayerAnimationControllerTest.cpp: + (WebKitTests::expectTranslateX): + (WebKitTests): + (WebKitTests::TEST): + * tests/CCLayerTreeHostTest.cpp: + (WTF::CCLayerTreeHostTest::dispatchAddAnimation): + (WTF::CCLayerTreeHostTest::doBeginTest): + +2012-02-23 James Robinson <jamesr@chromium.org> + + [chromium] Clean up GraphicsContext3D initialization paths + https://bugs.webkit.org/show_bug.cgi?id=79321 + + Reviewed by Kenneth Russell. + + This simplifies the GraphicsContext3D initialization paths down to two simple codepaths, one for offscreen + contexts initialized from WebCore and one for onscreen (compositor) contexts initialized by WebViewImpl or + WebLayerTreeViewImpl. + + Offscreen initialization path: + 1) WebCore code calls WebCore::GraphicsContext3D::create(), implemented in GraphicsContext3DChromium.cpp + 2) GraphicsContext3D::create() instantiates a WebGraphicsContext3D via the static WebKitPlatformSupport interface + 3) GraphicsContext3DPrivate::createGraphicsContextFromWebContext() wraps the WebGraphicsContext3D in a + GraphicsContext3D's m_private pointer. + + Onscreen initialization path: + 1) WebViewImpl or WebLayerTreeViewImpl request an onscreen WebGraphicsContext3D from either their WebViewClient + or WebLayerTreeViewClient, respectively + 2) GraphicsContext3DPrivate::createGraphicsContextFromWebContext() wraps the WebGraphicsContext3D in a + GraphicsContext3D's m_private pointer. + + There are no other initialization paths. Specifically, we do not support instantiating onscreen contexts from + within WebCore. + + * src/GraphicsContext3DChromium.cpp: + (WebCore::GraphicsContext3DPrivate::GraphicsContext3DPrivate): + (WebCore::GraphicsContext3DPrivate::createGraphicsContextFromWebContext): + (WebCore): + (WebCore::GraphicsContext3DPrivate::platformTexture): + (WebCore::GraphicsContext3D::create): + * src/GraphicsContext3DPrivate.h: + (GraphicsContext3DPrivate): + * src/WebLayerTreeViewImpl.cpp: + (WebKit::WebLayerTreeViewImpl::createLayerTreeHostContext3D): + * src/WebViewImpl.cpp: + (std::getCompositorContextAttributes): + (WebKit::WebViewImpl::createCompositorGraphicsContext3D): + (WebKit): + (WebKit::WebViewImpl::createLayerTreeHostContext3D): + (WebKit::WebViewImpl::graphicsContext3D): + * src/WebViewImpl.h: + (WebViewImpl): + * tests/CCLayerTreeHostImplTest.cpp: + (WebKit::CCLayerTreeHostImplTest::createContext): + (CCLayerTreeHostImplTest): + (WebKit::TEST_F): + * tests/CCLayerTreeHostTest.cpp: + (WTF::MockLayerTreeHostClient::createLayerTreeHostContext3D): + * tests/Canvas2DLayerChromiumTest.cpp: + (WebCore::Canvas2DLayerChromiumTest::fullLifecycleTest): + * tests/CompositorFakeGraphicsContext3D.h: + (WebCore::createCompositorMockGraphicsContext3D): + * tests/FakeGraphicsContext3DTest.cpp: + (TEST): + +2012-02-23 Jonathan Backer <backer@chromium.org> + + [chromium] Plumb video damage to the damage tracker. + https://bugs.webkit.org/show_bug.cgi?id=79373 + + Reviewed by James Robinson. + + * src/WebMediaPlayerClientImpl.cpp: + (WebKit::WebMediaPlayerClientImpl::repaint): + +2012-02-21 James Robinson <jamesr@chromium.org> + + [chromium] Notify compositor of wheel event registration via ScrollingCoordinator + https://bugs.webkit.org/show_bug.cgi?id=79133 + + Reviewed by Dimitri Glazkov. + + Rips out old wheel event notification and adds unit tests for new LayerChromium property. + + * src/NonCompositedContentHost.cpp: + (WebKit::NonCompositedContentHost::setViewport): + * src/WebCompositorInputHandlerImpl.cpp: + (WebKit::WebCompositorInputHandlerImpl::handleInputEvent): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::numberOfWheelEventHandlersChanged): + (WebKit::WebViewImpl::setIsAcceleratedCompositingActive): + * src/WebViewImpl.h: + * tests/CCLayerTreeHostImplTest.cpp: + (WebKit::TEST_F): + (WebKit): + * tests/LayerChromiumTest.cpp: + * tests/WebCompositorInputHandlerImplTest.cpp: + +2012-02-23 Adrienne Walker <enne@google.com> + + Unreviewed, rolling out r108666. + http://trac.webkit.org/changeset/108666 + https://bugs.webkit.org/show_bug.cgi?id=79321 + + Breaks webplugin tests: http://goo.gl/CoHIi + + * src/GraphicsContext3DChromium.cpp: + (WebCore::GraphicsContext3DPrivate::GraphicsContext3DPrivate): + (WebCore): + (WebCore::GraphicsContext3DPrivate::create): + (WebCore::GraphicsContext3DPrivate::createGraphicsContextFromWebContext): + (WebCore::GraphicsContext3DPrivate::createGraphicsContextForAnotherThread): + (WebCore::GraphicsContext3DPrivate::platformTexture): + (WebCore::GraphicsContext3D::create): + * src/GraphicsContext3DPrivate.h: + (WebKit): + (GraphicsContext3DPrivate): + * src/WebLayerTreeViewImpl.cpp: + (WebKit::WebLayerTreeViewImpl::createLayerTreeHostContext3D): + * src/WebViewImpl.cpp: + (std::getCompositorContextAttributes): + (WebKit::WebViewImpl::createLayerTreeHostContext3D): + (WebKit::WebViewImpl::graphicsContext3D): + * tests/CCLayerTreeHostImplTest.cpp: + (CCLayerTreeHostImplTest): + (WebKit::TEST_F): + * tests/CCLayerTreeHostTest.cpp: + (WTF::MockLayerTreeHostClient::createLayerTreeHostContext3D): + * tests/Canvas2DLayerChromiumTest.cpp: + (WebCore::Canvas2DLayerChromiumTest::fullLifecycleTest): + * tests/CompositorFakeGraphicsContext3D.h: + (WebCore::createCompositorMockGraphicsContext3D): + * tests/FakeGraphicsContext3DTest.cpp: + (TEST): + +2012-02-23 Daniel Sievers <sievers@chromium.org> + + [Chromium] Add video stream texture support + https://bugs.webkit.org/show_bug.cgi?id=78398 + + This upstreams the abstraction used on Android for + hardware video decoding with the compositor. + + Most of the interfaces are kept generic and the core + of this change is to allow texturing from an external + texture while receiving notifications (on the compositor + thread if we are running it) when there are new frames to + be displayed. + + Reviewed by James Robinson. + + * WebKit.gyp: + * public/WebMediaPlayer.h: + (WebKit): + (WebKit::WebMediaPlayer::setStreamTextureClient): + (WebMediaPlayer): + * public/WebStreamTextureClient.h: Copied from Source/WebKit/chromium/public/WebVideoFrame.h. + (WebKit): + (WebStreamTextureClient): + (WebKit::WebStreamTextureClient::~WebStreamTextureClient): + * public/WebVideoFrame.h: + * src/WebMediaPlayerClientImpl.cpp: + (WebKit::WebMediaPlayerClientImpl::~WebMediaPlayerClientImpl): + (WebKit::WebMediaPlayerClientImpl::setVideoFrameProviderClient): + (WebKit::WebMediaPlayerClientImpl::didReceiveFrame): + (WebKit): + (WebKit::WebMediaPlayerClientImpl::didUpdateMatrix): + * src/WebMediaPlayerClientImpl.h: + (WebMediaPlayerClientImpl): + +2012-02-22 James Robinson <jamesr@chromium.org> + + [chromium] Clean up GraphicsContext3D initialization paths + https://bugs.webkit.org/show_bug.cgi?id=79321 + + Reviewed by Kenneth Russell. + + This simplifies the GraphicsContext3D initialization paths down to two simple codepaths, one for offscreen + contexts initialized from WebCore and one for onscreen (compositor) contexts initialized by WebViewImpl or + WebLayerTreeViewImpl. + + Offscreen initialization path: + 1) WebCore code calls WebCore::GraphicsContext3D::create(), implemented in GraphicsContext3DChromium.cpp + 2) GraphicsContext3D::create() instantiates a WebGraphicsContext3D via the static WebKitPlatformSupport interface + 3) GraphicsContext3DPrivate::createGraphicsContextFromWebContext() wraps the WebGraphicsContext3D in a + GraphicsContext3D's m_private pointer. + + Onscreen initialization path: + 1) WebViewImpl or WebLayerTreeViewImpl request an onscreen WebGraphicsContext3D from either their WebViewClient + or WebLayerTreeViewClient, respectively + 2) GraphicsContext3DPrivate::createGraphicsContextFromWebContext() wraps the WebGraphicsContext3D in a + GraphicsContext3D's m_private pointer. + + There are no other initialization paths. Specifically, we do not support instantiating onscreen contexts from + within WebCore. + + * src/GraphicsContext3DChromium.cpp: + (WebCore::GraphicsContext3DPrivate::GraphicsContext3DPrivate): + (WebCore::GraphicsContext3DPrivate::createGraphicsContextFromWebContext): + (WebCore): + (WebCore::GraphicsContext3DPrivate::platformTexture): + (WebCore::GraphicsContext3D::create): + * src/GraphicsContext3DPrivate.h: + (GraphicsContext3DPrivate): + * src/WebLayerTreeViewImpl.cpp: + (WebKit::WebLayerTreeViewImpl::createLayerTreeHostContext3D): + * src/WebViewImpl.cpp: + (std::getCompositorContextAttributes): + (WebKit::WebViewImpl::createLayerTreeHostContext3D): + (WebKit::WebViewImpl::graphicsContext3D): + * tests/CCLayerTreeHostImplTest.cpp: + (WebKit::CCLayerTreeHostImplTest::createContext): + (CCLayerTreeHostImplTest): + (WebKit::TEST_F): + * tests/CCLayerTreeHostTest.cpp: + (WTF::MockLayerTreeHostClient::createLayerTreeHostContext3D): + * tests/Canvas2DLayerChromiumTest.cpp: + (WebCore::Canvas2DLayerChromiumTest::fullLifecycleTest): + * tests/CompositorFakeGraphicsContext3D.h: + (WebCore::createCompositorMockGraphicsContext3D): + * tests/FakeGraphicsContext3DTest.cpp: + (TEST): + +2012-02-23 Greg Billock <gbillock@google.com> + + Add UserGestureIndicator capability to Chromium API. + https://bugs.webkit.org/show_bug.cgi?id=77690 + + Reviewed by Darin Fisher. + + * WebKit.gyp: + * public/WebScopedUserGesture.h: Added. + * src/WebScopedUserGesture.cpp: Added. + +2012-02-23 Peter Beverloo <peter@chromium.org> + + Unreviewed, rolling out r108627 and r108630. + https://bugs.webkit.org/show_bug.cgi?id=79367 + + ffmpeg is creating issues and was just reverted upstream as well. + + * DEPS: + +2012-02-23 Peter Beverloo <peter@chromium.org> + + Unreviewed build fix. Remove the ffmpeg binary directory from the + Chromium-Windows DEPS file, following the commit done in the + Chromium repository: + http://src.chromium.org/viewvc/chrome?view=rev&revision=123123 + + * DEPS: + +2012-02-23 Peter Beverloo <peter@chromium.org> + + Unreviewed. Rolled DEPS. + + * DEPS: + +2012-02-22 Hajime Morrita <morrita@chromium.org> + + NOTIFICATIONS should be implemented as PageSupplement + https://bugs.webkit.org/show_bug.cgi?id=79052 + + Reviewed by Adam Barth. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2012-02-22 Dana Jansens <danakj@chromium.org> + + [chromium] Add unit test for surface occlusion + https://bugs.webkit.org/show_bug.cgi?id=79302 + + Reviewed by James Robinson. + + * tests/CCOcclusionTrackerTest.cpp: + (WebCore::TEST): + (WebCore): + +2012-02-22 James Robinson <jamesr@chromium.org> + + Remove GraphicsContext3D::paintsIntoCanvasBuffer and unify WebGL and canvas 2d logic + https://bugs.webkit.org/show_bug.cgi?id=79317 + + Reviewed by Kenneth Russell. + + Remove paintsIntoCanvasBuffer() implementations. + + * src/GraphicsContext3DChromium.cpp: + (WebCore): + * src/GraphicsContext3DPrivate.h: + +2012-02-22 Yuta Kitamura <yutak@chromium.org> + + Unreviewed, rolling out r108590. + http://trac.webkit.org/changeset/108590 + + I mistakenly disabled tests even though the fix was already + in. + + * tests/CCOcclusionTrackerTest.cpp: + (WebCore::TEST): + +2012-02-22 Yuta Kitamura <yutak@chromium.org> + + [Chromium] Unreviewed. Disable two tests from CCOcclusionTrackerTest + which cause assertion failures. + + * tests/CCOcclusionTrackerTest.cpp: + (WebCore): + (WebCore::TEST): + +2012-02-22 Dana Jansens <danakj@chromium.org> + + [chromium] Fix CCOcclusionTracker unit test assertion + https://bugs.webkit.org/show_bug.cgi?id=79275 + + Reviewed by James Robinson. + + * tests/CCOcclusionTrackerTest.cpp: + (WebCore::TEST): + +2012-02-22 Ian Vollick <vollick@chromium.org> + + [chromium] Plumb from GraphicsLayer to the cc thread animation code + https://bugs.webkit.org/show_bug.cgi?id=75874 + + Reviewed by James Robinson. + + * WebKit.gypi: + * public/WebSettings.h: + * public/platform/WebLayerTreeView.h: + (WebKit::WebLayerTreeView::Settings::Settings): + (Settings): + * src/WebLayerTreeView.cpp: + (WebKit::WebLayerTreeView::Settings::operator CCSettings): + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setThreadedAnimationEnabled): + (WebKit): + * src/WebSettingsImpl.h: + (WebSettingsImpl): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::setIsAcceleratedCompositingActive): + * tests/CCActiveAnimationTest.cpp: + (WebCore::createActiveAnimation): + * tests/CCAnimationTestCommon.cpp: Added. + (WebKitTests): + (WebKitTests::FakeFloatAnimationCurve::FakeFloatAnimationCurve): + (WebKitTests::FakeFloatAnimationCurve::~FakeFloatAnimationCurve): + (WebKitTests::FakeFloatAnimationCurve::clone): + (WebKitTests::FakeTransformTransition::FakeTransformTransition): + (WebKitTests::FakeTransformTransition::~FakeTransformTransition): + (WebKitTests::FakeTransformTransition::getValue): + (WebKitTests::FakeTransformTransition::clone): + (WebKitTests::FakeFloatTransition::FakeFloatTransition): + (WebKitTests::FakeFloatTransition::~FakeFloatTransition): + (WebKitTests::FakeFloatTransition::getValue): + (WebKitTests::FakeLayerAnimationControllerImplClient::FakeLayerAnimationControllerImplClient): + (WebKitTests::FakeLayerAnimationControllerImplClient::~FakeLayerAnimationControllerImplClient): + (WebKitTests::FakeFloatTransition::clone): + (WebKitTests::addOpacityTransition): + * tests/CCAnimationTestCommon.h: Added. + (WebCore): + (WebKitTests): + (FakeFloatAnimationCurve): + (WebKitTests::FakeFloatAnimationCurve::duration): + (WebKitTests::FakeFloatAnimationCurve::getValue): + (FakeTransformTransition): + (WebKitTests::FakeTransformTransition::duration): + (FakeFloatTransition): + (WebKitTests::FakeFloatTransition::duration): + (FakeLayerAnimationControllerImplClient): + (WebKitTests::FakeLayerAnimationControllerImplClient::id): + (WebKitTests::FakeLayerAnimationControllerImplClient::opacity): + (WebKitTests::FakeLayerAnimationControllerImplClient::setOpacity): + (WebKitTests::FakeLayerAnimationControllerImplClient::transform): + (WebKitTests::FakeLayerAnimationControllerImplClient::setTransform): + (WebKitTests::FakeLayerAnimationControllerImplClient::bounds): + * tests/CCLayerAnimationControllerImplTest.cpp: + (WebKitTests::createActiveAnimation): + (WebKitTests::TEST): + * tests/CCLayerAnimationControllerTest.cpp: Added. + (WebKitTests): + (WebKitTests::createActiveAnimation): + (WebKitTests::TEST): + * tests/CCLayerTreeHostImplTest.cpp: + (WebKit::CCLayerTreeHostImplTest::postAnimationEventsToMainThreadOnImplThread): + * tests/CCLayerTreeHostTest.cpp: + (WTF::TestHooks::animateLayers): + (MockLayerTreeHostImpl): + (WTF::MockLayerTreeHostImpl::animateLayers): + (WTF::MockLayerTreeHost::create): + (WTF::MockLayerTreeHost::createLayerTreeHostImpl): + (WTF): + (MockLayerAnimationController): + (WTF::MockLayerAnimationController::create): + (WTF::MockLayerAnimationController::addAnimation): + (WTF::MockLayerTreeHostClient::scheduleComposite): + (WTF::CCLayerTreeHostTest::postAddAnimationToMainThread): + (CCLayerTreeHostTest): + (WTF::CCLayerTreeHostTest::dispatchAddAnimation): + (WTF::CCLayerTreeHostTest::doBeginTest): + (CCLayerTreeHostTestAddAnimation): + (WTF::CCLayerTreeHostTestAddAnimation::CCLayerTreeHostTestAddAnimation): + (WTF::CCLayerTreeHostTestAddAnimation::beginTest): + (WTF::CCLayerTreeHostTestAddAnimation::animateLayers): + (WTF::CCLayerTreeHostTestAddAnimation::afterTest): + (WTF::TEST_F): + * tests/TreeSynchronizerTest.cpp: + (FakeLayerAnimationController): + (WebKitTests::FakeLayerAnimationController::create): + (WebKitTests::FakeLayerAnimationController::synchronizedAnimations): + (WebKitTests::FakeLayerAnimationController::FakeLayerAnimationController): + (WebKitTests::FakeLayerAnimationController::synchronizeAnimations): + (WebKitTests): + (WebKitTests::TEST): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * src/EditorClientImpl.cpp: + (WebKit::EditorClientImpl::shouldApplyStyle): + * src/EditorClientImpl.h: + (EditorClientImpl): + +2012-02-22 Daniel Cheng <dcheng@chromium.org> + + [chromium] Cleanup unused WebDragData methods after r107846 + https://bugs.webkit.org/show_bug.cgi?id=78837 + + Reviewed by Tony Chang. + + The deleted methods have been replaced by items() and setItems(). + + * public/platform/WebDragData.h: + (WebDragData): + * src/WebDragData.cpp: + (WebKit::WebDragData::addItem): Add ensureMutable() call to verify preconditions for + mutating the item store. + +2012-02-22 Tim Dresser <tdresser@chromium.org> + + CCLayerTreeHostImpl calls didDraw more frequently than willDraw + https://bugs.webkit.org/show_bug.cgi?id=79139 + + Reviewed by James Robinson. + + * tests/CCLayerTreeHostImplTest.cpp: + (WebKit::DidDrawCheckLayer::willDraw): + (DidDrawCheckLayer): + (WebKit::DidDrawCheckLayer::willDrawCalled): + (WebKit::DidDrawCheckLayer::DidDrawCheckLayer): + (WebKit::TEST_F): + (WebKit): + +2012-02-22 Dana Jansens <danakj@chromium.org> + + [Chromium] New CCOcclusionTracker class with tests + https://bugs.webkit.org/show_bug.cgi?id=78549 + + Reviewed by James Robinson. + + * WebKit.gypi: + * tests/CCLayerTreeHostCommonTest.cpp: + (WebCore): + * tests/CCOcclusionTrackerTest.cpp: Added. + (WebCore): + (WebCore::setLayerPropertiesForTesting): + (LayerChromiumWithForcedDrawsContent): + (WebCore::LayerChromiumWithForcedDrawsContent::LayerChromiumWithForcedDrawsContent): + (WebCore::LayerChromiumWithForcedDrawsContent::drawsContent): + (TestCCOcclusionTracker): + (WebCore::TestCCOcclusionTracker::occlusionInScreenSpace): + (WebCore::TestCCOcclusionTracker::occlusionInTargetSurface): + (WebCore::TestCCOcclusionTracker::setOcclusionInScreenSpace): + (WebCore::TestCCOcclusionTracker::setOcclusionInTargetSurface): + (WebCore::TEST): + +2012-02-22 Hao Zheng <zhenghao@chromium.org> + + [chromium] Build WebKit with MEDIA_STREAM disabled. + https://bugs.webkit.org/show_bug.cgi?id=79214 + + Reviewed by Kent Tamura. + + * src/UserMediaClientImpl.h: + +2012-02-20 Roland Steiner <rolandsteiner@chromium.org> + + <style scoped>: Add runtime-flag + https://bugs.webkit.org/show_bug.cgi?id=79074 + + Added a runtime-flag. + Enable default STYLE_SCOPED compile-time flag for Chromium. + + Reviewed by Dimitri Glazkov. + + * features.gypi: enable STYLE_SCOPED + * public/WebRuntimeFeatures.h: + (WebRuntimeFeatures): + * src/WebRuntimeFeatures.cpp: + (WebKit::WebRuntimeFeatures::enableStyleScoped): + (WebKit): + (WebKit::WebRuntimeFeatures::isStyleScopedEnabled): + +2012-02-22 Yuta Kitamura <yutak@chromium.org> + + Unreviewed, rolling out r108453. + http://trac.webkit.org/changeset/108453 + https://bugs.webkit.org/show_bug.cgi?id=78549 + + Broke Chromium's webkit_unit_tests. + + * WebKit.gypi: + * tests/CCLayerTreeHostCommonTest.cpp: + (WebCore::TEST): + (WebCore): + * tests/CCOcclusionTrackerTest.cpp: Removed. + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * src/EditorClientImpl.cpp: + (WebKit::EditorClientImpl::shouldApplyStyle): + * src/EditorClientImpl.h: + (EditorClientImpl): + +2012-02-22 Dana Jansens <danakj@chromium.org> + + [chromium] Cull quads outside of the scissoring damage rect + https://bugs.webkit.org/show_bug.cgi?id=79181 + + Reviewed by James Robinson. + + * tests/CCQuadCullerTest.cpp: + (WebCore::TEST): + (WebCore): + +2012-02-21 Dana Jansens <danakj@chromium.org> + + [Chromium] New CCOcclusionTracker class with tests + https://bugs.webkit.org/show_bug.cgi?id=78549 + + Reviewed by James Robinson. + + * WebKit.gypi: + * tests/CCLayerTreeHostCommonTest.cpp: + (WebCore): + * tests/CCOcclusionTrackerTest.cpp: Added. + (WebCore): + (WebCore::setLayerPropertiesForTesting): + (LayerChromiumWithForcedDrawsContent): + (WebCore::LayerChromiumWithForcedDrawsContent::LayerChromiumWithForcedDrawsContent): + (WebCore::LayerChromiumWithForcedDrawsContent::drawsContent): + (TestCCOcclusionTracker): + (WebCore::TestCCOcclusionTracker::occlusionInScreenSpace): + (WebCore::TestCCOcclusionTracker::occlusionInTargetSurface): + (WebCore::TestCCOcclusionTracker::setOcclusionInScreenSpace): + (WebCore::TestCCOcclusionTracker::setOcclusionInTargetSurface): + (WebCore::TEST): + +2012-02-21 MORITA Hajime <morrita@google.com> + + INPUT_SPEECH should be implemented as a PageSupplement. + https://bugs.webkit.org/show_bug.cgi?id=79051 + + Reviewed by Adam Barth. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2012-02-20 MORITA Hajime <morrita@google.com> + + MEDIA_STREAM should be implemented as a PageSupplement. + https://bugs.webkit.org/show_bug.cgi?id=79050 + + Reviewed by Adam Barth. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2012-02-21 Dana Jansens <danakj@chromium.org> + + [chromium] Painting a layer clears opaque rect in untouched tiles + https://bugs.webkit.org/show_bug.cgi?id=79157 + + Reviewed by James Robinson. + + * tests/TiledLayerChromiumTest.cpp: + (WTF::TEST): + +2012-02-21 James Robinson <jamesr@chromium.org> + + Enable ScrollingCoordinator in chromium whenever compositing is enabled + https://bugs.webkit.org/show_bug.cgi?id=79165 + + Reviewed by Adam Barth. + + * src/NonCompositedContentHost.cpp: + (WebKit::NonCompositedContentHost::setViewport): + Whenever the ScrollingCoordinator is enabled the scroll layer's position is expected to be updated + externally to RenderLayerCompositor, so set it here. + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setAcceleratedCompositingEnabled): + +2012-02-21 Daniel Cheng <dcheng@chromium.org> + + [chromium] Fix image drag out on Chromium + https://bugs.webkit.org/show_bug.cgi?id=79158 + + Reviewed by Tony Chang. + + We constructed the WebDragData::Item for dragging out an image but never added it to the + item list. This is normally covered by the fast/events/drag-image-filename.html layout test, + but the bug wasn't caught in the original patch since the implementations in Chrome and DRT + had diverged. + + * src/WebDragData.cpp: + (WebKit::WebDragData::items): + +2012-02-21 David Grogan <dgrogan@chromium.org> + + IndexedDB: webFrame isn't threadsafe, don't use it from a worker thread + https://bugs.webkit.org/show_bug.cgi?id=78659 + + After crrev.com/121669, indexed db doesn't use the web frame for + anything if called from a web worker. + + No new tests - this check was defensive and possibly not ever + triggered. + + Reviewed by Tony Chang. + + * src/IDBFactoryBackendProxy.cpp: + (WebKit::IDBFactoryBackendProxy::openFromWorker): + +2012-02-21 Yury Semikhatsky <yurys@chromium.org> + + [V8] Web Inspector: set breakpoint/pause doesn't work when worker is in a tight loop + https://bugs.webkit.org/show_bug.cgi?id=79097 + + Worker script execution will be interrupted for dispatching inspector commands. + + Reviewed by Pavel Feldman. + + * src/WebSharedWorkerImpl.cpp: + (WebKit::WebSharedWorkerImpl::dispatchDevToolsMessage): + +2012-02-20 Peter Beverloo <peter@chromium.org> + + Unreviewed. Rolled DEPS. + + * DEPS: + +2012-02-20 Kenichi Ishibashi <bashi@chromium.org> + + [WebSocket] Add deflater/inflater classes + https://bugs.webkit.org/show_bug.cgi?id=78449 + + Add tests which ensure WebSocketDeflater/WebSocketInflater can + compress/decompress data correctly. + + Reviewed by Kent Tamura. + + * WebKit.gypi: Added zlib dependency. + * WebKitUnitTests.gyp: Ditto. + * tests/WebSocketDeflaterTest.cpp: Added. + (WebCore): + (WebCore::TEST): + +2012-02-17 Yury Semikhatsky <yurys@chromium.org> + + [Chromium] Web Inspector: terminated workers are not removed from dedicated worker list + https://bugs.webkit.org/show_bug.cgi?id=78899 + + Pass original WorkerContextProxy object to the inspector instrumentation instead + of Chromium-specific one for consistency with WorkerMessagingProxy implementation + in WebCore. + + Reviewed by Pavel Feldman. + + * src/WebWorkerClientImpl.cpp: + (WebKit::WebWorkerClientImpl::startWorkerContext): + +2012-02-18 raman Tenneti <rtenneti@chromium.org> + + Track the NPN protocol version negotiated with the server + https://bugs.webkit.org/show_bug.cgi?id=77349 + + Reviewed by Darin Fisher. + + [chromium] Added ExtraData to WebURLResponse. + + * WebKit.gypi: + * public/platform/WebURLResponse.h: + (ExtraData): + (WebKit::WebURLResponse::ExtraData::~ExtraData): + (WebURLResponse): + * src/WebURLResponse.cpp: + (WebKit::WebURLResponse::extraData): + (WebKit): + (WebKit::WebURLResponse::setExtraData): + * tests/WebURLResponseTest.cpp: Added. + (WebKit): + (TestExtraData): + (WebKit::TestExtraData::TestExtraData): + (WebKit::TestExtraData::~TestExtraData): + (WebKit::TEST): + +2012-02-17 Joshua Bell <jsbell@chromium.org> + + IndexedDB: Support overloaded methods that take IDBKey or IDBKeyRange + https://bugs.webkit.org/show_bug.cgi?id=78399 + + Implements the WebKit API for IDBObjectStore.delete(IDBKeyRange), + to exercise the overload capability. + + Reviewed by Tony Chang. + + * src/IDBObjectStoreBackendProxy.cpp: + (WebKit::IDBObjectStoreBackendProxy::deleteFunction): + (WebKit): + * src/IDBObjectStoreBackendProxy.h: + (IDBObjectStoreBackendProxy): + * src/WebIDBObjectStoreImpl.cpp: + (WebKit::WebIDBObjectStoreImpl::deleteFunction): + (WebKit): + * src/WebIDBObjectStoreImpl.h: + (WebIDBObjectStoreImpl): + +2012-02-17 Michal Mocny <mmocny@google.com> + + [chromium] GL_CHROMIUM_gpu_memory_manager extension + https://bugs.webkit.org/show_bug.cgi?id=77155 + + Reviewed by James Robinson. + + * public/platform/WebGraphicsContext3D.h: + (WebGraphicsMemoryAllocationChangedCallbackCHROMIUM): + (WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM::~WebGraphicsMemoryAllocationChangedCallbackCHROMIUM): + (WebGraphicsContext3D): + (WebKit::WebGraphicsContext3D::setMemoryAllocationChangedCallbackCHROMIUM): + * src/Extensions3DChromium.cpp: + (WebCore::Extensions3DChromium::setGpuMemoryAllocationChangedCallbackCHROMIUM): + (WebCore): + * src/GraphicsContext3DChromium.cpp: + (WebCore::GraphicsContext3D::~GraphicsContext3D): + (GraphicsContext3DMemoryAllocationChangedCallbackAdapter): + (WebCore::GraphicsContext3DMemoryAllocationChangedCallbackAdapter::GraphicsContext3DMemoryAllocationChangedCallbackAdapter): + (WebCore::GraphicsContext3DMemoryAllocationChangedCallbackAdapter::~GraphicsContext3DMemoryAllocationChangedCallbackAdapter): + (WebCore::GraphicsContext3DMemoryAllocationChangedCallbackAdapter::onMemoryAllocationChanged): + (WebCore): + (WebCore::GraphicsContext3DPrivate::setGpuMemoryAllocationChangedCallbackCHROMIUM): + * src/GraphicsContext3DPrivate.h: + (WebCore): + * tests/FakeWebGraphicsContext3D.h: + (WebKit::FakeWebGraphicsContext3D::setMemoryAllocationChangedCallbackCHROMIUM): + (FakeWebGraphicsContext3D): + +2012-02-17 Mihnea Ovidenie <mihnea@adobe.com> + + CSS regions enabled by default + https://bugs.webkit.org/show_bug.cgi?id=78525 + + Reviewed by David Hyatt. + + Add a runtime preference to enable/disable regions functionality at runtime(WebKitCSSRegionsEnabled). + CSSRegions are still enabled by default. + In DRT, use layoutTestController.overridePreference("WebKitCSSRegionsEnabled", "0") to disable the css regions functionality. + + * public/WebSettings.h: + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setExperimentalCSSRegionsEnabled): + (WebKit): + * src/WebSettingsImpl.h: + (WebSettingsImpl): + +2012-02-17 Scott Graham <scottmg@chromium.org> + + [Chromium] pack Gamepad shared memory structure + https://bugs.webkit.org/show_bug.cgi?id=78022 + + Reviewed by Darin Fisher. + + Add #pragma pack around definition of shared memory structures to + avoid differences across compilers and platforms. Add COMPILE_ASSERT + to verify expected size. + + * public/platform/WebGamepad.h: + (WebKit): + * public/platform/WebGamepads.h: + (WebKit): + +2012-02-17 Tim Dresser <tdresser@chromium.org> + + [chromium] Refactor video drawing to be more data driven + https://bugs.webkit.org/show_bug.cgi?id=76720 + + Reviewed by James Robinson. + + CCLayerTreeHostImplTest.didDrawCalledOnAllLayers ensures that + CCLayerImpl::didDraw() is called on all layers, including layers + on different render surfaces. + + * tests/CCLayerTreeHostImplTest.cpp: + (DidDrawCheckLayer): + (WebKit::DidDrawCheckLayer::create): + (WebKit::DidDrawCheckLayer::didDraw): + (WebKit::DidDrawCheckLayer::didDrawCalled): + (WebKit::DidDrawCheckLayer::DidDrawCheckLayer): + (WebKit): + (WebKit::TEST_F): + +2012-02-17 Ilya Tikhonovsky <loislo@chromium.org> + + Unreviewed, rolling out r108071. + http://trac.webkit.org/changeset/108071 + https://bugs.webkit.org/show_bug.cgi?id=77155 + + chromium-mac compilation failed + + * public/platform/WebGraphicsContext3D.h: + (WebGraphicsContext3D): + * src/Extensions3DChromium.cpp: + * src/GraphicsContext3DChromium.cpp: + (WebCore::GraphicsContext3D::~GraphicsContext3D): + * src/GraphicsContext3DPrivate.h: + (WebCore): + * tests/FakeWebGraphicsContext3D.h: + +2012-02-17 Michal Mocny <mmocny@google.com> + + [chromium] GL_CHROMIUM_gpu_memory_manager extension + https://bugs.webkit.org/show_bug.cgi?id=77155 + + Reviewed by James Robinson. + + * public/platform/WebGraphicsContext3D.h: + (WebGraphicsMemoryAllocationChangedCallbackCHROMIUM): + (WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM::~WebGraphicsMemoryAllocationChangedCallbackCHROMIUM): + (WebGraphicsContext3D): + (WebKit::WebGraphicsContext3D::setMemoryAllocationChangedCallbackCHROMIUM): + * src/Extensions3DChromium.cpp: + (WebCore::Extensions3DChromium::setGpuMemoryAllocationChangedCallbackCHROMIUM): + (WebCore): + * src/GraphicsContext3DChromium.cpp: + (WebCore::GraphicsContext3D::~GraphicsContext3D): + (GraphicsContext3DMemoryAllocationChangedCallbackAdapter): + (WebCore::GraphicsContext3DMemoryAllocationChangedCallbackAdapter::GraphicsContext3DMemoryAllocationChangedCallbackAdapter): + (WebCore::GraphicsContext3DMemoryAllocationChangedCallbackAdapter::~GraphicsContext3DMemoryAllocationChangedCallbackAdapter): + (WebCore::GraphicsContext3DMemoryAllocationChangedCallbackAdapter::onMemoryAllocationChanged): + (WebCore): + (WebCore::GraphicsContext3DPrivate::setGpuMemoryAllocationChangedCallbackCHROMIUM): + * src/GraphicsContext3DPrivate.h: + (WebCore): + * tests/FakeWebGraphicsContext3D.h: + (WebKit::FakeWebGraphicsContext3D::setMemoryAllocationChangedCallbackCHROMIUM): + (FakeWebGraphicsContext3D): + +2012-02-17 Ilya Tikhonovsky <loislo@chromium.org> + + Unreviewed. Chromium DEPS roll + + * DEPS: from 122122 to 122498 + +2012-02-16 Alexandre Elias <aelias@google.com> + + [chromium] Bundle page scale factor and limits in CCLayerTreeHost + https://bugs.webkit.org/show_bug.cgi?id=78762 + + Setting page scale factor and its limits in separate methods + may cause clamping bugs if one of them makes it to the + impl thread before the other. Change the API to bundle them together, + which matches the existing impl-side interface. + + Reviewed by James Robinson. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::computePageScaleFactorLimits): + (WebKit::WebViewImpl::setIsAcceleratedCompositingActive): + (WebKit::WebViewImpl::updateLayerTreeViewport): + * tests/CCLayerTreeHostTest.cpp: + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::applyScrollAndScale): + +2012-02-16 Varun Jain <varunjain@google.com> + + [Chromium] Add method to WebViewImpl to extract zoom/scroll params for gesture events on touch devices + https://bugs.webkit.org/show_bug.cgi?id=72909 + + Reviewed by James Robinson. + + * src/WebViewImpl.cpp: + (std): + (WebKit): + (WebKit::WebViewImpl::computeBlockBounds): + (WebKit::WebViewImpl::widenRectWithinPageBounds): + (WebKit::WebViewImpl::computeScaleAndScrollForHitRect): + * src/WebViewImpl.h: + (WebViewImpl): + * tests/WebFrameTest.cpp: + (WebKit): + (WebKit::TEST_F): + * tests/data/get_scale_for_auto_zoom_into_div_test.html: Added. + +2012-02-16 Sami Kyostila <skyostil@chromium.org> + + [chromium] LayerChromium::setNeedsDisplay does not apply contents scale correctly + https://bugs.webkit.org/show_bug.cgi?id=77464 + + Added a new unit test for TiledLayerChromium to verify its invalidation behavior when + the contents scale changes. Also enhance and existing unit test for LayerChromium to + verify the paint rectangle dimensions instead just checking that it is not empty. + + Reviewed by James Robinson. + + * tests/LayerChromiumTest.cpp: + * tests/TiledLayerChromiumTest.cpp: + (WTF::FakeTiledLayerChromium::setNeedsDisplayRect): + (FakeTiledLayerChromium): + (WTF::FakeTiledLayerChromium::lastNeedsDisplayRect): + (WTF::TEST): + (WTF): + +2012-02-16 MORITA Hajime <morrita@google.com> + + https://bugs.webkit.org/show_bug.cgi?id=78065 + [Chromium] Should eliminate WebTextCheckingResult legacy APIs + + Reviewed by Kent Tamura. + + Removed unused legacy members. + + * public/WebTextCheckingResult.h: + (WebKit::WebTextCheckingResult::WebTextCheckingResult): + (WebTextCheckingResult): + * src/AssertMatchingEnums.cpp: + +2012-02-16 Evan Martin <evan@chromium.org> + + [chromium] pull third_party/gold to fix linux build + https://bugs.webkit.org/show_bug.cgi?id=78842 + + Reviewed by Tony Chang. + + The Chrome build now depends on third_party/gold also being checked out. + + * DEPS: + +2012-02-15 Michael Nordman <michaeln@google.com> + + Fix bugs in the implementation of WebDatabase::closeDatabaseImmediately. + https://bugs.webkit.org/show_bug.cgi?id=78841 + + WebDatabase now delegates this function entirely to DatabaseTracker. + This is part of resolving http://crbug.com/98939 + + Reviewed by David Levin. + + * src/WebDatabase.cpp: + (WebKit::WebDatabase::closeDatabaseImmediately): + +2012-02-16 Dana Jansens <danakj@chromium.org> + + [Chromium] Occlusion tracking with CSS filters + https://bugs.webkit.org/show_bug.cgi?id=77498 + + Reviewed by James Robinson. + + * tests/CCLayerTreeHostTest.cpp: + (CCLayerTreeHostTestLayerOcclusionWithFilters): + (WTF::CCLayerTreeHostTestLayerOcclusionWithFilters::CCLayerTreeHostTestLayerOcclusionWithFilters): + (WTF::CCLayerTreeHostTestLayerOcclusionWithFilters::beginTest): + (WTF::CCLayerTreeHostTestLayerOcclusionWithFilters::afterTest): + (WTF): + +2012-02-16 Joshua Bell <jsbell@chromium.org> + + IndexedDB: Chromium WebKit API support for IDBObjectStore.delete(IDBKeyRange) + https://bugs.webkit.org/show_bug.cgi?id=78619 + + Add an overload to WebIDBObjectStore::deleteFunction(). First part of a two-sided patch. + + Reviewed by Darin Fisher. + + * public/WebIDBObjectStore.h: + (WebKit::WebIDBObjectStore::deleteFunction): + +2012-02-16 Dana Jansens <danakj@chromium.org> + + [chromium] Clipping/Transforms applied in wrong order in opaque paint tracking + https://bugs.webkit.org/show_bug.cgi?id=78775 + + Reviewed by Stephen White. + + * tests/PlatformContextSkiaTest.cpp: + (WebCore::TEST): + +2012-02-16 Daniel Cheng <dcheng@chromium.org> + + [chromium] Add WEBKIT_EXPORT to new WebDragData methods. + https://bugs.webkit.org/show_bug.cgi?id=78843 + + Reviewed by Tony Chang. + + * public/platform/WebDragData.h: + (WebDragData): + +2012-02-16 Viet-Trung Luu <viettrungluu@chromium.org> + + [chromium] Add method to WebPluginContainer to check if a rectangle is topmost + https://bugs.webkit.org/show_bug.cgi?id=78166 + + Reviewed by Darin Fisher. + + * public/WebPluginContainer.h: + (WebPluginContainer): + * src/WebPluginContainerImpl.cpp: + * src/WebPluginContainerImpl.h: + (WebPluginContainerImpl): + +2012-02-16 Yosifumi Inoue <yosin@chromium.org> + + Build Fix: R107894 breaks Chromium Linux Build. + https://bugs.webkit.org/show_bug.cgi?id=78790 + + WebDragDataPrivate::types, inherited from ChromiumDataObject, returns PassRef<DOMStringList> since r107894. However, WebDragData expected to get old return value type HashSet<String>. + + Reviewed by Kent Tamura. + + * src/WebDragData.cpp: + (WebKit::WebDragData::items): Use RefPtr<DOMStringList> rather than HashSet<String> for value of m_private->types(). + +2012-02-15 Sami Kyostila <skyostil@google.com> + + Enable -webkit-overflow-scrolling CSS property + https://bugs.webkit.org/show_bug.cgi?id=78664 + + Reviewed by Eric Seidel. + + * features.gypi: + +2012-02-15 Tommy Widenflycht <tommyw@google.com> + + MediaStream API: Removing SecurityContext from the embedder API + https://bugs.webkit.org/show_bug.cgi?id=73816 + + Reviewed by Darin Fisher. + + * bridge/PeerConnectionHandler.cpp: + (WebCore::PeerConnectionHandler::create): + (WebCore::PeerConnectionHandler::PeerConnectionHandler): + * bridge/PeerConnectionHandlerInternal.cpp: + (WebCore::PeerConnectionHandlerInternal::PeerConnectionHandlerInternal): + * bridge/PeerConnectionHandlerInternal.h: + (WebCore): + (PeerConnectionHandlerInternal): + * public/platform/WebPeerConnectionHandler.h: + (WebPeerConnectionHandler): + (WebKit::WebPeerConnectionHandler::initialize): + +2012-02-15 Peter Beverloo <peter@chromium.org> + + [Chromium] Roll DEPS to r122122 + https://bugs.webkit.org/show_bug.cgi?id=78754 + + Unreviewed DEPS roll. + + * DEPS: + +2012-02-01 Daniel Cheng <dcheng@chromium.org> + + [chromium] Add setter/getter to expose drag data as a list of items + https://bugs.webkit.org/show_bug.cgi?id=77125 + + This change supports the unification of the data store backing ChromiumDataObject and + DataTransferItemListChromium. ChromiumDataObject will represent dragging and clipboard data + as a list of data nodes to make it more straightforward to implement the HTML spec for + DataTransferItemList. Thus, we extend the abstraction to the webkit glue layer to + simplify the serialization/deserialization between platform-specific data and WebDragData. + The other setter/getter methods are deprecated and will be removed once the dependencies in + Chromium code are gone. + + Reviewed by Darin Fisher. + + * public/platform/WebDragData.h: + (WebKit): + (WebDragData): + * src/WebDragData.cpp: + (WebKit::WebDragData::items): + (WebKit): + (WebKit::WebDragData::setItems): + (WebKit::WebDragData::addItem): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * public/WebViewClient.h: + (WebKit::WebViewClient::numberOfTouchEventHandlersChanged): + * src/ChromeClientImpl.cpp: + (WebKit::ChromeClientImpl::numTouchEventHandlersChanged): + (WebKit): + * src/ChromeClientImpl.h: + (ChromeClientImpl): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::numberOfTouchEventHandlersChanged): + (WebKit): + * src/WebViewImpl.h: + (WebViewImpl): + +2012-02-15 Anders Carlsson <andersca@apple.com> + + Remove ScrollableArea::handleGestureEvent + https://bugs.webkit.org/show_bug.cgi?id=78661 + + Reviewed by Adam Roben. + + Update for WebCore changes. + + * src/WebPluginContainerImpl.cpp: + * src/WebPluginContainerImpl.h: + (WebPluginContainerImpl): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::gestureEvent): + +2012-02-14 Takashi Toyoshima <toyoshim@chromium.org> + + Provide SocketStreamHandleInternal::toWebSocketStreamHandle(SocketStreamHandle*). + https://bugs.webkit.org/show_bug.cgi?id=78581 + + Reviewed by Kent Tamura. + + Now, there is no way to convert SocketStreamHandle to + WebSocketStreamHandle. In subsequent changes, I'll use this function + in FrameLoaderClientImpl. + + * src/SocketStreamHandle.cpp: Remove SocketStreamHandleInternal class declaration. + * src/SocketStreamHandleInternal.h: Move SocketStreamHandleInternal class declaration from SocketStreamHandle.cpp to expose, and add conversion function to WebSocketStreamHandle from SocketStreamHandle. + (WebKit): + (WebCore): + (SocketStreamHandleInternal): + (WebCore::SocketStreamHandleInternal::create): + (WebCore::SocketStreamHandleInternal::toWebSocketStreamHandle): + * WebKit.gyp: Add SocketStreamHandleInternal.h entry. + +2012-02-14 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r107766. + http://trac.webkit.org/changeset/107766 + https://bugs.webkit.org/show_bug.cgi?id=78665 + + Breaks Chromium Win build (Requested by bashi1 on #webkit). + + * WebKit.gypi: + * tests/WebSocketDeflaterTest.cpp: Removed. + +2012-02-14 Kenichi Ishibashi <bashi@chromium.org> + + [WebSocket] Add extension attribute support + https://bugs.webkit.org/show_bug.cgi?id=78557 + + Add WebSocketExtensionDispatcher::acceptedExtensions() checks. + + Reviewed by Kent Tamura. + + * tests/WebSocketExtensionDispatcherTest.cpp: + (WebCore::TEST_F): + +2012-02-14 Kenichi Ishibashi <bashi@chromium.org> + + [WebSocket] Add deflater/inflater classes. + https://bugs.webkit.org/show_bug.cgi?id=78449 + + Add tests which ensure WebSocketDeflater/WebSocketInflater can + compress/decompress data correctly. + + Reviewed by Kent Tamura. + + * WebKit.gypi: + * tests/WebSocketDeflaterTest.cpp: Added. + (WebCore): + (WebCore::TEST): + +2012-02-14 Dana Jansens <danakj@chromium.org> + + [chromium] Compare filters on impl thread when setting them, and test setting in unit tests + https://bugs.webkit.org/show_bug.cgi?id=78643 + + Reviewed by James Robinson. + + * tests/CCLayerImplTest.cpp: + (WebCore::TEST): + +2012-02-14 Ramya Chandrasekaran <cramya@google.com> + + Last character display for passwords in Android. + https://bugs.webkit.org/show_bug.cgi?id=78532 + + Reviewed by Adam Barth. + + * public/WebSettings.h: + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setPasswordEchoEnabled): + (WebKit): + (WebKit::WebSettingsImpl::setPasswordEchoDurationInSeconds): + * src/WebSettingsImpl.h: + (WebSettingsImpl): + +2012-02-14 David Reveman <reveman@chromium.org> + + [Chromium] Expose perTilePainting setting through WebLayerTreeView::Settings interface. + https://bugs.webkit.org/show_bug.cgi?id=76937 + + Reviewed by James Robinson. + + Add perTilePainting to WebLayerTreeView::Settings. + + * public/platform/WebLayerTreeView.h: + (WebKit::WebLayerTreeView::Settings::Settings): + (Settings): + * src/WebLayerTreeView.cpp: + (WebKit::WebLayerTreeView::Settings::operator CCSettings): + +2012-02-14 Vsevolod Vlasov <vsevik@chromium.org> + + Web Inspector: Make ScriptsNavigator default file selector. + https://bugs.webkit.org/show_bug.cgi?id=78349 + + Reviewed by Pavel Feldman. + + * src/js/Tests.js: + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.checkNoDuplicates): + (.TestSuite.prototype.uiSourceCodesToString_): + (.TestSuite.prototype.nonAnonymousUISourceCodes_): + (.TestSuite.prototype._scriptsAreParsed): + (.TestSuite.prototype._waitUntilScriptsAreParsed.waitForAllScripts): + (.TestSuite.prototype._waitUntilScriptsAreParsed): + +2012-02-14 Hayato Ito <hayato@chromium.org> + + Make ShadowRoot.nodeType return DOCUMENT_FRAGMENT_NODE. + https://bugs.webkit.org/show_bug.cgi?id=77514 + + Reviewed by Dimitri Glazkov. + + NodeType.SHADOW_ROOT_NODE type is finally gone. + + * src/WebPageSerializerImpl.cpp: + (WebKit::WebPageSerializerImpl::buildContentForNode): + +2012-02-14 David Reveman <reveman@chromium.org> + + [Chromium] Inconsistent initialization of CCSettings in WebLayerTreeView. + https://bugs.webkit.org/show_bug.cgi?id=76927 + + Reviewed by James Robinson. + + Remove unnecessary initialization and include maxPartialTextureUpdates + in FIXME comment. + + * src/WebLayerTreeView.cpp: + (WebKit::WebLayerTreeView::Settings::operator CCSettings): + +2012-02-14 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r107661. + http://trac.webkit.org/changeset/107661 + https://bugs.webkit.org/show_bug.cgi?id=78591 + + crash on lion/qt bots (Requested by hayato on #webkit). + + * src/WebPageSerializerImpl.cpp: + (WebKit::WebPageSerializerImpl::buildContentForNode): + +2012-02-14 Yuzhu Shen <yzshen@chromium.com> + + [chromium] Pepper plugins don't receive mouse movement information in + non-mouse-lock mode. + https://bugs.webkit.org/show_bug.cgi?id=78014 + + This change makes WebMouseEventBuilder pass along mouse movement + information properly. + + There isn't test for this change because: + - the movement information added is only used by pepper, and there + isn't any test for pepper at the WebKit side. (WebKit doesn't know + about pepper.) + - this change is trivial. It just copies two newly-added data fields + from MouseEvent to WebMouseEventBuilder during conversion. + + Reviewed by Tony Chang. + + * src/WebInputEventConversion.cpp: + (WebKit::WebMouseEventBuilder::WebMouseEventBuilder): + +2012-02-11 Nikolas Zimmermann <nzimmermann@rim.com> + + Convert svg/animations to use SMIL methods for driving the timeline + https://bugs.webkit.org/show_bug.cgi?id=78422 + + Reviewed by Dirk Schulze. + + Remove SVG animation sampling functionality provided for DRT, which no longer uses it. + Instead we switched the svg/animations tests to use SVGSVGElement.setCurrentTime. + + * public/WebFrame.h: + (WebFrame): + * src/WebFrameImpl.cpp: + * src/WebFrameImpl.h: + (WebFrameImpl): + +2012-02-13 Mihai Parparita <mihaip@chromium.org> + + [Chromium] Remove BoundObject + https://bugs.webkit.org/show_bug.cgi?id=78531 + + Reviewed by Pavel Feldman. + + Remove the BoundObject class, references to it were removed in r56999. + + * WebKit.gyp: + * src/BoundObject.cpp: Removed. + * src/BoundObject.h: Removed. + * src/WebDevToolsFrontendImpl.cpp: + +2012-02-13 W. James MacLean <wjmaclean@chromium.org> + + [chromium] Remove obsolete zoom animation pathway. + https://bugs.webkit.org/show_bug.cgi?id=78359 + + Reviewed by James Robinson. + + This patch removes dead code from the previous incarnation of zoom animation for chromium. + + * src/WebViewImpl.cpp: + +2012-02-13 Hayato Ito <hayato@chromium.org> + + Make ShadowRoot.nodeType return DOCUMENT_FRAGMENT_NODE. + https://bugs.webkit.org/show_bug.cgi?id=77514 + + Reviewed by Dimitri Glazkov. + + NodeType.SHADOW_ROOT_NODE type is finally gone. + + * src/WebPageSerializerImpl.cpp: + (WebKit::WebPageSerializerImpl::buildContentForNode): + +2012-02-13 Nico Weber <thakis@chromium.org> + + [chromium] Let WebKit::initialize call InitWebCoreSystemInterface on mac. + https://bugs.webkit.org/show_bug.cgi?id=78246 + + This allows removing a bunch of code in chromium land (https://chromiumcodereview.appspot.com/9374020/), + and helps with the component build on mac (InitWebCoreSystemInterface is not an + exported function, and it shouldn't be). + + Source/WebKit/mac/WebCoreSupport/WebSystemInterface.mm early-returns when it's + called twice, so it's safe to land this change, and remove the calls in client + code in a later CL. + + Reviewed by Darin Fisher. + + * src/WebKit.cpp: + (WebKit::initializeWithoutV8): + +2012-02-13 Yosifumi Inoue <yosin@chromium.org> + + [Forms] Use enum instead of bool for HTMLInputElement::setValue + https://bugs.webkit.org/show_bug.cgi?id=75217 + + Reviewed by Kent Tamura. + + * src/WebInputElement.cpp: + (WebKit::WebInputElement::setValue): Use enum for HTMLInputElement::setValue + +2012-02-12 Hajime Morrita <morrita@chromium.org> + + Page should have less intrusive way to associate API implementation objects. + https://bugs.webkit.org/show_bug.cgi?id=78085 + + Reviewed by Adam Barth. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2012-02-10 David Grogan <dgrogan@chromium.org> + + Disable IndexedDB permissions check from shared workers + https://bugs.webkit.org/show_bug.cgi?id=78316 + + We want to temporarily bypass this check because it causes a crash + when called from a shared worker. We'll have to fix it before + including idb on shared workers in a release but don't want to stop + developers from testing out idb on shared workers. + + No new tests because it affects shared workers only, which aren't + testable by DRT. + + Reviewed by Tony Chang. + + * src/IDBFactoryBackendProxy.cpp: + (WebKit::IDBFactoryBackendProxy::allowIDBFromWorkerThread): + +2012-02-10 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed. Rolled DEPS. + + * DEPS: + +2012-02-09 Kenichi Ishibashi <bashi@chromium.org> + + Add WebSocket extension support + https://bugs.webkit.org/show_bug.cgi?id=78079 + + Add some tests which check WebSocketExtensions::processHeaderValue() + parses the given response correctly. + + Reviewed by Kent Tamura. + + * WebKit.gypi: + * tests/WebSocketExtensionDispatcherTest.cpp: Added. + (WebCore): + (MockWebSocketExtensionProcessor): + (WebCore::MockWebSocketExtensionProcessor::MockWebSocketExtensionProcessor): + (WebSocketExtensionDispatcherTest): + (WebCore::WebSocketExtensionDispatcherTest::WebSocketExtensionDispatcherTest): + (WebCore::WebSocketExtensionDispatcherTest::SetUp): + (WebCore::WebSocketExtensionDispatcherTest::TearDown): + (WebCore::WebSocketExtensionDispatcherTest::addMockProcessor): + (WebCore::WebSocketExtensionDispatcherTest::appendResult): + (WebCore::MockWebSocketExtensionProcessor::processResponse): + (WebCore::TEST_F): + +2012-02-09 W. James MacLean <wjmaclean@chromium.org> + + [chromium] Add support for starting page/scale animations on CC impl thread from WebViewImpl + https://bugs.webkit.org/show_bug.cgi?id=77872 + + Reviewed by James Robinson. + + Provides a pathway to invoke CCLayerTreeHostImpl::startPageScaleAnimation() from + WebViewImpl. This is intended to support scale and scroll animations, such as WebInputEvent::GestureDoubleTap. + + * src/WebViewImpl.cpp: + (WebKit): + (WebKit::WebViewImpl::startPageScaleAnimation): + * src/WebViewImpl.h: + (WebViewImpl): + * tests/CCLayerTreeHostTest.cpp: + (WTF): + (CCLayerTreeHostTestStartPageScaleAnimation): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::CCLayerTreeHostTestStartPageScaleAnimation): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::beginTest): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::requestStartPageScaleAnimation): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::drawLayersOnCCThread): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::applyScrollAndScale): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::commitCompleteOnCCThread): + (WTF::CCLayerTreeHostTestStartPageScaleAnimation::afterTest): + (WTF::TEST_F): + +2012-02-09 John Bates <jbates@google.com> + + [Chromium] Add chromium-style tracing support + https://bugs.webkit.org/show_bug.cgi?id=76885 + + Reviewed by Darin Fisher. + + This code enables WebKit trace events to pass through more data to the + chromium platform tracing API and generally to use the full tracing + API provided by chromium. + + * public/platform/WebKitPlatformSupport.h: + (WebKit::WebKitPlatformSupport::getTraceCategoryEnabledFlag): + (WebKit::WebKitPlatformSupport::addTraceEvent): + * src/PlatformSupport.cpp: + (WebCore::PlatformSupport::getTraceCategoryEnabledFlag): + (WebCore::PlatformSupport::addTraceEvent): + +2012-02-09 Jonathan Backer <backer@chromium.org> + + [chromium] Plumb setNeedsRedraw. + https://bugs.webkit.org/show_bug.cgi?id=78248 + + Reviewed by James Robinson. + + * public/platform/WebLayerTreeView.h: + (WebLayerTreeView): + * src/WebLayerTreeView.cpp: + (WebKit::WebLayerTreeView::setNeedsRedraw): + (WebKit): + +2012-02-09 Jonathan Backer <backer@chromium.org> + + [chromium] Add setNeedsRedraw to WebWidget + https://bugs.webkit.org/show_bug.cgi?id=77555 + + Reviewed by James Robinson. + + * public/WebWidget.h: + (WebWidget): + (WebKit::WebWidget::setNeedsRedraw): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::setNeedsRedraw): + (WebKit): + * src/WebViewImpl.h: + (WebViewImpl): + 2012-02-08 Raymond Liu <raymond.liu@intel.com> Fix a typo for r107125 diff --git a/Source/WebKit/chromium/DEPS b/Source/WebKit/chromium/DEPS index 2e0adf6f0..ba422445c 100644 --- a/Source/WebKit/chromium/DEPS +++ b/Source/WebKit/chromium/DEPS @@ -32,7 +32,7 @@ vars = { 'chromium_svn': 'http://src.chromium.org/svn/trunk/src', - 'chromium_rev': '121041' + 'chromium_rev': '123353' } deps = { @@ -163,6 +163,8 @@ deps_os = { # Linux, actually. 'tools/xdisplaycheck': Var('chromium_svn')+'/tools/xdisplaycheck@'+Var('chromium_rev'), + 'third_party/gold': + From('chromium_deps', 'src/third_party/gold'), 'third_party/openssl': From('chromium_deps', 'src/third_party/openssl'), }, diff --git a/Source/WebKit/chromium/WebKit.gyp b/Source/WebKit/chromium/WebKit.gyp index 12ac1ab22..f8e58b383 100644 --- a/Source/WebKit/chromium/WebKit.gyp +++ b/Source/WebKit/chromium/WebKit.gyp @@ -232,6 +232,7 @@ 'public/WebReferrerPolicy.h', 'public/WebRegularExpression.h', 'public/WebRuntimeFeatures.h', + 'public/WebScopedUserGesture.h', 'public/WebScreenInfo.h', 'public/WebScriptController.h', 'public/WebScriptSource.h', @@ -256,6 +257,7 @@ 'public/WebStorageNamespace.h', 'public/WebStorageQuotaCallbacks.h', 'public/WebStorageQuotaType.h', + 'public/WebStreamTextureClient.h', 'public/WebTextAffinity.h', 'public/WebTextCaseSensitivity.h', 'public/WebTextCheckingCompletion.h', @@ -372,8 +374,6 @@ 'src/BackForwardListChromium.h', 'src/BlobRegistryProxy.cpp', 'src/BlobRegistryProxy.h', - 'src/BoundObject.cpp', - 'src/BoundObject.h', 'src/CCThreadImpl.cpp', 'src/CCThreadImpl.h', 'src/ChromeClientImpl.cpp', @@ -465,6 +465,7 @@ 'src/ScrollbarGroup.h', 'src/SharedWorkerRepository.cpp', 'src/SocketStreamHandle.cpp', + 'src/SocketStreamHandleInternal.h', 'src/SpeechInputClientImpl.cpp', 'src/SpeechInputClientImpl.h', 'src/StorageAreaProxy.cpp', @@ -633,6 +634,7 @@ 'src/WebRange.cpp', 'src/WebRegularExpression.cpp', 'src/WebRuntimeFeatures.cpp', + 'src/WebScopedUserGesture.cpp', 'src/WebScriptController.cpp', 'src/WebScrollbarImpl.cpp', 'src/WebScrollbarImpl.h', @@ -668,6 +670,7 @@ 'src/WebURLResponse.cpp', 'src/WebURLResponsePrivate.h', 'src/WebURLError.cpp', + 'src/WebScopedUserGesture.cpp', 'src/WebUserMediaRequest.cpp', 'src/WebViewImpl.cpp', 'src/WebViewImpl.h', diff --git a/Source/WebKit/chromium/WebKit.gypi b/Source/WebKit/chromium/WebKit.gypi index c8502f573..e91e336db 100644 --- a/Source/WebKit/chromium/WebKit.gypi +++ b/Source/WebKit/chromium/WebKit.gypi @@ -61,10 +61,14 @@ 'tests/AssociatedURLLoaderTest.cpp', 'tests/Canvas2DLayerChromiumTest.cpp', 'tests/CCActiveAnimationTest.cpp', + 'tests/CCAnimationTestCommon.cpp', + 'tests/CCAnimationTestCommon.h', 'tests/CCDamageTrackerTest.cpp', 'tests/CCDelayBasedTimeSourceTest.cpp', 'tests/CCFrameRateControllerTest.cpp', + 'tests/CCKeyframedAnimationCurveTest.cpp', 'tests/CCLayerAnimationControllerImplTest.cpp', + 'tests/CCLayerAnimationControllerTest.cpp', 'tests/CCLayerImplTest.cpp', 'tests/CCLayerIteratorTest.cpp', 'tests/CCLayerQuadTest.cpp', @@ -75,6 +79,7 @@ 'tests/CCLayerTreeHostImplTest.cpp', 'tests/CCLayerTreeHostTest.cpp', 'tests/CCLayerTreeTestCommon.h', + 'tests/CCOcclusionTrackerTest.cpp', 'tests/CCQuadCullerTest.cpp', 'tests/CCRenderSurfaceTest.cpp', 'tests/CCSchedulerStateMachineTest.cpp', @@ -118,7 +123,10 @@ 'tests/WebLayerTest.cpp', 'tests/WebPageNewSerializerTest.cpp', 'tests/WebPageSerializerTest.cpp', + 'tests/WebSocketDeflaterTest.cpp', + 'tests/WebSocketExtensionDispatcherTest.cpp', 'tests/WebURLRequestTest.cpp', + 'tests/WebURLResponseTest.cpp', 'tests/WebViewTest.cpp', ], diff --git a/Source/WebKit/chromium/WebKitUnitTests.gyp b/Source/WebKit/chromium/WebKitUnitTests.gyp index 5a98a8459..d50ad1523 100644 --- a/Source/WebKit/chromium/WebKitUnitTests.gyp +++ b/Source/WebKit/chromium/WebKitUnitTests.gyp @@ -61,6 +61,7 @@ '<(chromium_src_dir)/base/base.gyp:base', '<(chromium_src_dir)/base/base.gyp:base_i18n', '<(chromium_src_dir)/base/base.gyp:test_support_base', + '<(chromium_src_dir)/third_party/zlib/zlib.gyp:zlib', '<(chromium_src_dir)/webkit/support/webkit_support.gyp:webkit_support', '<(chromium_src_dir)/webkit/support/webkit_support.gyp:webkit_user_agent', ], diff --git a/Source/WebKit/chromium/bridge/PeerConnectionHandler.cpp b/Source/WebKit/chromium/bridge/PeerConnectionHandler.cpp index e9bd9e82d..c59b2d46c 100644 --- a/Source/WebKit/chromium/bridge/PeerConnectionHandler.cpp +++ b/Source/WebKit/chromium/bridge/PeerConnectionHandler.cpp @@ -36,17 +36,16 @@ #include "PeerConnectionHandlerClient.h" #include "PeerConnectionHandlerInternal.h" -#include "SecurityOrigin.h" namespace WebCore { -PassOwnPtr<PeerConnectionHandler> PeerConnectionHandler::create(PeerConnectionHandlerClient* client, const String& serverConfiguration, PassRefPtr<SecurityOrigin> securityOrigin) +PassOwnPtr<PeerConnectionHandler> PeerConnectionHandler::create(PeerConnectionHandlerClient* client, const String& serverConfiguration, const String& username) { - return adoptPtr(new PeerConnectionHandler(client, serverConfiguration, securityOrigin)); + return adoptPtr(new PeerConnectionHandler(client, serverConfiguration, username)); } -PeerConnectionHandler::PeerConnectionHandler(PeerConnectionHandlerClient* client, const String& serverConfiguration, PassRefPtr<SecurityOrigin> securityOrigin) - : m_private(adoptPtr(new PeerConnectionHandlerInternal(client, serverConfiguration, securityOrigin))) +PeerConnectionHandler::PeerConnectionHandler(PeerConnectionHandlerClient* client, const String& serverConfiguration, const String& username) + : m_private(adoptPtr(new PeerConnectionHandlerInternal(client, serverConfiguration, username))) { } diff --git a/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.cpp b/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.cpp index cfc33584a..d8f61f7f0 100644 --- a/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.cpp +++ b/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.cpp @@ -45,15 +45,21 @@ namespace WebCore { -PeerConnectionHandlerInternal::PeerConnectionHandlerInternal(PeerConnectionHandlerClient* client, const String& serverConfiguration, PassRefPtr<SecurityOrigin> securityOrigin) +PeerConnectionHandlerInternal::PeerConnectionHandlerInternal(PeerConnectionHandlerClient* client, const String& serverConfiguration, const String& username) : m_client(client) { ASSERT(m_client); m_webHandler = adoptPtr(WebKit::webKitPlatformSupport()->createPeerConnectionHandler(this)); // FIXME: When there is some error reporting avaliable in the PeerConnection object report // if we didn't get a WebPeerConnectionHandler instance. - if (m_webHandler) - m_webHandler->initialize(serverConfiguration, securityOrigin); + + if (m_webHandler) { + // Dual calls due to API change + m_webHandler->initialize(serverConfiguration, username); + + // DEPRECATED + m_webHandler->initialize(serverConfiguration, SecurityOrigin::createFromString(username)); + } } PeerConnectionHandlerInternal::~PeerConnectionHandlerInternal() diff --git a/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.h b/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.h index a3e79e0ac..e17fd96b5 100644 --- a/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.h +++ b/Source/WebKit/chromium/bridge/PeerConnectionHandlerInternal.h @@ -48,11 +48,10 @@ class WebMediaStreamDescriptor; namespace WebCore { class PeerConnectionHandlerClient; -class SecurityOrigin; class PeerConnectionHandlerInternal : public WebKit::WebPeerConnectionHandlerClient { public: - PeerConnectionHandlerInternal(PeerConnectionHandlerClient*, const String& serverConfiguration, PassRefPtr<SecurityOrigin>); + PeerConnectionHandlerInternal(PeerConnectionHandlerClient*, const String& serverConfiguration, const String& username); ~PeerConnectionHandlerInternal(); virtual void produceInitialOffer(const MediaStreamDescriptorVector& pendingAddStreams); diff --git a/Source/WebKit/chromium/features.gypi b/Source/WebKit/chromium/features.gypi index 4cca26795..4c46d4de4 100644 --- a/Source/WebKit/chromium/features.gypi +++ b/Source/WebKit/chromium/features.gypi @@ -73,6 +73,7 @@ 'ENABLE_MUTATION_OBSERVERS=<(enable_mutation_observers)', 'ENABLE_NOTIFICATIONS=1', 'ENABLE_ORIENTATION_EVENTS=0', + 'ENABLE_OVERFLOW_SCROLLING=1', 'ENABLE_PAGE_VISIBILITY_API=1', 'ENABLE_POINTER_LOCK=1', 'ENABLE_PROGRESS_TAG=1', @@ -84,7 +85,7 @@ 'ENABLE_SHARED_WORKERS=1', 'ENABLE_SMOOTH_SCROLLING=1', 'ENABLE_SQL_DATABASE=1', - 'ENABLE_STYLE_SCOPED=0', + 'ENABLE_STYLE_SCOPED=1', 'ENABLE_SVG=<(enable_svg)', 'ENABLE_SVG_FONTS=<(enable_svg)', 'ENABLE_TOUCH_EVENTS=<(enable_touch_events)', diff --git a/Source/WebKit/chromium/public/WebFrame.h b/Source/WebKit/chromium/public/WebFrame.h index 9574c490e..0d5406d52 100644 --- a/Source/WebKit/chromium/public/WebFrame.h +++ b/Source/WebKit/chromium/public/WebFrame.h @@ -624,12 +624,6 @@ public: // Returns true if selection.anchorNode has a marker on range from |from| with |length|. virtual bool selectionStartHasSpellingMarkerFor(int from, int length) const = 0; - // Pauses and samples an SVG animation. Returns false if there's no svg - // animation to pause. This is only for testing. - virtual bool pauseSVGAnimation(const WebString& animationId, - double time, - const WebString& elementId) = 0; - // Dumps the layer tree, used by the accelerated compositor, in // text form. This is used only by layout tests. virtual WebString layerTreeAsText(bool showDebugInfo = false) const = 0; diff --git a/Source/WebKit/chromium/public/WebIDBObjectStore.h b/Source/WebKit/chromium/public/WebIDBObjectStore.h index 6bd51f419..981f5ec7e 100644 --- a/Source/WebKit/chromium/public/WebIDBObjectStore.h +++ b/Source/WebKit/chromium/public/WebIDBObjectStore.h @@ -69,6 +69,7 @@ public: virtual void put(const WebSerializedScriptValue&, const WebIDBKey&, PutMode, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&) { WEBKIT_ASSERT_NOT_REACHED(); } virtual void deleteFunction(const WebIDBKey&, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&) { WEBKIT_ASSERT_NOT_REACHED(); } + virtual void deleteFunction(const WebIDBKeyRange&, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&) { WEBKIT_ASSERT_NOT_REACHED(); } virtual void clear(WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&) { WEBKIT_ASSERT_NOT_REACHED(); } virtual WebIDBIndex* createIndex(const WebString& name, const WebString& keyPath, bool unique, bool multiEntry, const WebIDBTransaction& transaction, WebExceptionCode& ec) { diff --git a/Source/WebKit/chromium/public/WebMediaPlayer.h b/Source/WebKit/chromium/public/WebMediaPlayer.h index 9aaf1a3d0..239134963 100644 --- a/Source/WebKit/chromium/public/WebMediaPlayer.h +++ b/Source/WebKit/chromium/public/WebMediaPlayer.h @@ -40,6 +40,7 @@ namespace WebKit { class WebAudioSourceProvider; class WebAudioSourceProviderClient; class WebMediaPlayerClient; +class WebStreamTextureClient; class WebURL; struct WebRect; struct WebSize; @@ -162,6 +163,8 @@ public: // method should no longer be referenced after the call is made. virtual void putCurrentFrame(WebVideoFrame*) { } + virtual void setStreamTextureClient(WebStreamTextureClient*) { } + virtual WebAudioSourceProvider* audioSourceProvider() { return 0; } virtual bool sourceAppend(const unsigned char* data, unsigned length) { return false; } diff --git a/Source/WebKit/chromium/public/WebPluginContainer.h b/Source/WebKit/chromium/public/WebPluginContainer.h index 122c4c8df..845cb1a28 100644 --- a/Source/WebKit/chromium/public/WebPluginContainer.h +++ b/Source/WebKit/chromium/public/WebPluginContainer.h @@ -100,6 +100,10 @@ public: // Notifies that the zoom level has changed. virtual void zoomLevelChanged(double zoomLevel) = 0; + // Determines whether the given rectangle in this plugin is above all other + // content. The rectangle is in the plugin's coordinate system. + virtual bool isRectTopmost(const WebRect&) = 0; + virtual WebPlugin* plugin() = 0; virtual void setPlugin(WebPlugin*) = 0; diff --git a/Source/WebKit/chromium/public/WebRuntimeFeatures.h b/Source/WebKit/chromium/public/WebRuntimeFeatures.h index 7e29ab0db..34e3947f6 100644 --- a/Source/WebKit/chromium/public/WebRuntimeFeatures.h +++ b/Source/WebKit/chromium/public/WebRuntimeFeatures.h @@ -124,6 +124,9 @@ public: WEBKIT_EXPORT static void enableShadowDOM(bool); WEBKIT_EXPORT static bool isShadowDOMEnabled(); + WEBKIT_EXPORT static void enableStyleScoped(bool); + WEBKIT_EXPORT static bool isStyleScopedEnabled(); + private: WebRuntimeFeatures(); }; diff --git a/Source/WebKit/chromium/src/BoundObject.h b/Source/WebKit/chromium/public/WebScopedUserGesture.h index 394ff7c9e..14798f153 100644 --- a/Source/WebKit/chromium/src/BoundObject.h +++ b/Source/WebKit/chromium/public/WebScopedUserGesture.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 Google Inc. All rights reserved. + * Copyright (C) 2011 Google Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -28,34 +28,33 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef BoundObject_h -#define BoundObject_h +#ifndef WebScopedUserGesture_h +#define WebScopedUserGesture_h -#include <v8.h> -#include <wtf/Noncopyable.h> +#include "platform/WebPrivateOwnPtr.h" + +namespace WebCore { +class UserGestureIndicator; +} namespace WebKit { -// BoundObject is a helper class that lets you map JavaScript method calls -// directly to C++ method calls. It should be destroyed once JS object is -// built. -class BoundObject { - WTF_MAKE_NONCOPYABLE(BoundObject); +// An instance of this class, while kept alive, will indicate that we are in +// the context of a known user gesture. To use, create one, perform whatever +// actions were done under color of a known user gesture, and then delete it. +// Usually this will be done on the stack. +class WebScopedUserGesture { public: - BoundObject(v8::Handle<v8::Context> context, void* v8This, const char* objectName); - virtual ~BoundObject(); - - void addProtoFunction(const char* name, v8::InvocationCallback callback); - void build(); + WebScopedUserGesture() { initialize(); } + ~WebScopedUserGesture() { reset(); } private: - v8::HandleScope m_handleScope; - const char* m_objectName; - v8::Handle<v8::Context> m_context; - v8::Persistent<v8::FunctionTemplate> m_hostTemplate; - void* m_v8This; + WEBKIT_EXPORT void initialize(); + WEBKIT_EXPORT void reset(); + + WebPrivateOwnPtr<WebCore::UserGestureIndicator> m_indicator; }; } // namespace WebKit -#endif +#endif // WebScopedUserGesture_h diff --git a/Source/WebKit/chromium/public/WebSettings.h b/Source/WebKit/chromium/public/WebSettings.h index 25ac07523..7f1bbb0c4 100644 --- a/Source/WebKit/chromium/public/WebSettings.h +++ b/Source/WebKit/chromium/public/WebSettings.h @@ -96,6 +96,7 @@ public: virtual void setOfflineWebApplicationCacheEnabled(bool) = 0; virtual void setWebAudioEnabled(bool) = 0; virtual void setExperimentalWebGLEnabled(bool) = 0; + virtual void setExperimentalCSSRegionsEnabled(bool) = 0; virtual void setOpenGLMultisamplingEnabled(bool) = 0; virtual void setPrivilegedWebGLExtensionsEnabled(bool) = 0; virtual void setWebGLErrorsToConsoleEnabled(bool) = 0; @@ -132,6 +133,8 @@ public: virtual void setFullScreenEnabled(bool) = 0; virtual void setAllowDisplayOfInsecureContent(bool) = 0; virtual void setAllowRunningOfInsecureContent(bool) = 0; + virtual void setPasswordEchoEnabled(bool) = 0; + virtual void setPasswordEchoDurationInSeconds(double) = 0; virtual void setShouldPrintBackgrounds(bool) = 0; virtual void setEnableScrollAnimator(bool) = 0; virtual void setHixie76WebSocketProtocolEnabled(bool) = 0; @@ -139,6 +142,7 @@ public: virtual void setAcceleratedPaintingEnabled(bool) = 0; virtual void setPerTilePaintingEnabled(bool) = 0; virtual void setPartialSwapEnabled(bool) = 0; + virtual void setThreadedAnimationEnabled(bool) = 0; protected: ~WebSettings() { } diff --git a/Source/WebKit/chromium/public/WebStreamTextureClient.h b/Source/WebKit/chromium/public/WebStreamTextureClient.h new file mode 100644 index 000000000..81002fb26 --- /dev/null +++ b/Source/WebKit/chromium/public/WebStreamTextureClient.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebStreamTextureClient_h +#define WebStreamTextureClient_h + +namespace WebKit { + +class WebStreamTextureClient { +public: + virtual void didReceiveFrame() = 0; + virtual void didUpdateMatrix(const float*) = 0; + +protected: + virtual ~WebStreamTextureClient() { } +}; + +} // namespace WebKit + +#endif diff --git a/Source/WebKit/chromium/public/WebTextCheckingResult.h b/Source/WebKit/chromium/public/WebTextCheckingResult.h index 8d0a745cc..e46f48cdc 100644 --- a/Source/WebKit/chromium/public/WebTextCheckingResult.h +++ b/Source/WebKit/chromium/public/WebTextCheckingResult.h @@ -34,7 +34,6 @@ #include "WebTextCheckingType.h" #include "platform/WebCommon.h" #include "platform/WebString.h" -#include "platform/WebVector.h" namespace WebCore { struct TextCheckingResult; @@ -44,50 +43,19 @@ namespace WebKit { // A checked entry of text checking. struct WebTextCheckingResult { - // FIXME: Should be removed after we confirm Chromium does not use it. - enum Error { - ErrorSpelling = 1 << 0, - ErrorGrammar = 1 << 1 - }; - WebTextCheckingResult() : type(WebTextCheckingTypeSpelling) - , error(ErrorSpelling) - , position(0) , location(0) , length(0) { } - explicit WebTextCheckingResult(Error e, int p = 0, int l = 0) - : type(WebTextCheckingTypeSpelling) - , error(e) - , position(p) - , location(p) - , length(l) - { - if (e & ErrorSpelling) - type = WebTextCheckingTypeSpelling; - else if (e & ErrorGrammar) - type = WebTextCheckingTypeGrammar; - else - WEBKIT_ASSERT_NOT_REACHED(); - } - WebTextCheckingResult(WebTextCheckingType type, int location, int length, const WebString& replacement = WebString()) : type(type) - , error(ErrorSpelling) - , position(location) , location(location) , length(length) , replacement(replacement) { - if (type & WebTextCheckingTypeSpelling) - error = ErrorSpelling; - else if (type & WebTextCheckingTypeGrammar) - error = ErrorGrammar; - else - WEBKIT_ASSERT_NOT_REACHED(); } #if WEBKIT_IMPLEMENTATION @@ -95,8 +63,6 @@ struct WebTextCheckingResult { #endif WebTextCheckingType type; - Error error; // FIXME: Should be removed after we confirm Chromium does not use it. - int position; // FIXME: Should be removed after we confirm Chromium does not use it. int location; int length; WebString replacement; diff --git a/Source/WebKit/chromium/public/WebVideoFrame.h b/Source/WebKit/chromium/public/WebVideoFrame.h index 8e3b2cdbd..78790627d 100644 --- a/Source/WebKit/chromium/public/WebVideoFrame.h +++ b/Source/WebKit/chromium/public/WebVideoFrame.h @@ -61,6 +61,7 @@ public: virtual int stride(unsigned plane) const { return 0; } virtual const void* data(unsigned plane) const { return 0; } virtual unsigned textureId() const { return 0; } + virtual unsigned textureTarget() const { return 0; } }; } // namespace WebKit diff --git a/Source/WebKit/chromium/public/WebViewClient.h b/Source/WebKit/chromium/public/WebViewClient.h index 1b42a48a8..b656fd5ad 100644 --- a/Source/WebKit/chromium/public/WebViewClient.h +++ b/Source/WebKit/chromium/public/WebViewClient.h @@ -263,6 +263,7 @@ public: virtual void focusedNodeChanged(const WebNode&) { } virtual void numberOfWheelEventHandlersChanged(unsigned) { } + virtual void numberOfTouchEventHandlersChanged(unsigned) { } // Indicates two things: // 1) This view may have a new layout now. diff --git a/Source/WebKit/chromium/public/WebWidget.h b/Source/WebKit/chromium/public/WebWidget.h index ca160a26e..58f3fa169 100644 --- a/Source/WebKit/chromium/public/WebWidget.h +++ b/Source/WebKit/chromium/public/WebWidget.h @@ -107,6 +107,11 @@ public: // animate or layout in this case. virtual void composite(bool finish) = 0; + // Temporary method for the embedder to notify the WebWidget that the widget + // has taken damage, e.g. due to a window expose. This method will be + // removed when the WebWidget inversion patch lands --- http://crbug.com/112837 + virtual void setNeedsRedraw() { } + // Called to inform the WebWidget of a change in theme. // Implementors that cache rendered copies of widgets need to re-render // on receiving this message diff --git a/Source/WebKit/chromium/public/platform/WebDragData.h b/Source/WebKit/chromium/public/platform/WebDragData.h index 171231eca..a6c82aee1 100644 --- a/Source/WebKit/chromium/public/platform/WebDragData.h +++ b/Source/WebKit/chromium/public/platform/WebDragData.h @@ -32,7 +32,9 @@ #define WebDragData_h #include "WebCommon.h" +#include "WebData.h" #include "WebString.h" +#include "WebURL.h" #if WEBKIT_IMPLEMENTATION namespace WebCore { class ChromiumDataObject; } @@ -41,15 +43,45 @@ namespace WTF { template <typename T> class PassRefPtr; } namespace WebKit { -class WebData; class WebDragDataPrivate; -class WebURL; template <typename T> class WebVector; // Holds data that may be exchanged through a drag-n-drop operation. It is // inexpensive to copy a WebDragData object. class WebDragData { public: + struct Item { + enum StorageType { + // String data with an associated MIME type. Depending on the MIME type, there may be + // optional metadata attributes as well. + StorageTypeString, + // Stores the name of one file being dragged into the renderer. + StorageTypeFilename, + // An image being dragged out of the renderer. Contains a buffer holding the image data + // as well as the suggested name for saving the image to. + StorageTypeBinaryData, + }; + + StorageType storageType; + + // Only valid when storageType == StorageTypeString. + WebString stringType; + WebString stringData; + + // Only valid when storageType == StorageTypeFilename. + WebString filenameData; + + // Only valid when storageType == StorageTypeBinaryData. + WebData binaryData; + + // Title associated with a link when stringType == "text/uri-list". + // Filename when storageType == StorageTypeBinaryData. + WebString title; + + // Only valid when stringType == "text/html". + WebURL baseURL; + }; + ~WebDragData() { reset(); } WebDragData() : m_private(0) { } @@ -66,44 +98,9 @@ public: bool isNull() const { return !m_private; } - WEBKIT_EXPORT WebString url() const; - WEBKIT_EXPORT void setURL(const WebURL&); - - WEBKIT_EXPORT WebString urlTitle() const; - WEBKIT_EXPORT void setURLTitle(const WebString&); - - WEBKIT_EXPORT WebString downloadMetadata() const; - WEBKIT_EXPORT void setDownloadMetadata(const WebString&); - - WEBKIT_EXPORT WebString fileExtension() const; - WEBKIT_EXPORT void setFileExtension(const WebString&); - - WEBKIT_EXPORT bool containsFilenames() const; - WEBKIT_EXPORT void filenames(WebVector<WebString>&) const; - WEBKIT_EXPORT void setFilenames(const WebVector<WebString>&); - WEBKIT_EXPORT void appendToFilenames(const WebString&); - - WEBKIT_EXPORT WebString plainText() const; - WEBKIT_EXPORT void setPlainText(const WebString&); - - WEBKIT_EXPORT WebString htmlText() const; - WEBKIT_EXPORT void setHTMLText(const WebString&); - - WEBKIT_EXPORT WebURL htmlBaseURL() const; - WEBKIT_EXPORT void setHTMLBaseURL(const WebURL&); - - WEBKIT_EXPORT WebString fileContentFilename() const; - WEBKIT_EXPORT void setFileContentFilename(const WebString&); - - WEBKIT_EXPORT WebData fileContent() const; - WEBKIT_EXPORT void setFileContent(const WebData&); - - struct CustomData { - WebString type; - WebString data; - }; - WEBKIT_EXPORT WebVector<CustomData> customData() const; - WEBKIT_EXPORT void setCustomData(const WebVector<CustomData>&); + WEBKIT_EXPORT WebVector<Item> items() const; + WEBKIT_EXPORT void setItems(const WebVector<Item>&); + WEBKIT_EXPORT void addItem(const Item&); #if WEBKIT_IMPLEMENTATION WebDragData(const WTF::PassRefPtr<WebCore::ChromiumDataObject>&); diff --git a/Source/WebKit/chromium/public/platform/WebGamepad.h b/Source/WebKit/chromium/public/platform/WebGamepad.h index 71d37b3ba..788e78ba4 100644 --- a/Source/WebKit/chromium/public/platform/WebGamepad.h +++ b/Source/WebKit/chromium/public/platform/WebGamepad.h @@ -26,8 +26,14 @@ #include "WebCommon.h" +#if WEBKIT_IMPLEMENTATION +#include <wtf/Assertions.h> +#endif + namespace WebKit { +#pragma pack(push, 1) + // This structure is intentionally POD and fixed size so that it can be shared // memory between hardware polling threads and the rest of the browser. See // also WebGamepads.h. @@ -69,6 +75,12 @@ public: float buttons[buttonsLengthCap]; }; +#if WEBKIT_IMPLEMENTATION +COMPILE_ASSERT(sizeof(WebGamepad) == 465, WebGamepad_has_wrong_size); +#endif + +#pragma pack(pop) + } #endif // WebGamepad_h diff --git a/Source/WebKit/chromium/public/platform/WebGamepads.h b/Source/WebKit/chromium/public/platform/WebGamepads.h index b1cc18ef8..50e2ab208 100644 --- a/Source/WebKit/chromium/public/platform/WebGamepads.h +++ b/Source/WebKit/chromium/public/platform/WebGamepads.h @@ -26,8 +26,14 @@ #include "WebGamepad.h" +#if WEBKIT_IMPLEMENTATION +#include <wtf/Assertions.h> +#endif + namespace WebKit { +#pragma pack(push, 1) + // This structure is intentionally POD and fixed size so that it can be stored // in shared memory between hardware polling threads and the rest of the // browser. @@ -45,6 +51,12 @@ public: WebGamepad items[itemsLengthCap]; }; +#if WEBKIT_IMPLEMENTATION +COMPILE_ASSERT(sizeof(WebGamepads) == 1864, WebGamepads_has_wrong_size); +#endif + +#pragma pack(pop) + } #endif // WebGamepads_h diff --git a/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h b/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h index 57f9d7985..f13f7c44d 100644 --- a/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h +++ b/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h @@ -130,6 +130,14 @@ public: virtual ~WebGraphicsSwapBuffersCompleteCallbackCHROMIUM() { } }; + class WebGraphicsMemoryAllocationChangedCallbackCHROMIUM { + public: + virtual void onMemoryAllocationChanged(size_t gpuResourceSizeInBytes) = 0; + + protected: + virtual ~WebGraphicsMemoryAllocationChangedCallbackCHROMIUM() { } + }; + // This destructor needs to be public so that using classes can destroy instances if initialization fails. virtual ~WebGraphicsContext3D() {} @@ -151,6 +159,9 @@ public: // GL_CHROMIUM_setVisibility - Changes the visibility of the backbuffer virtual void setVisibilityCHROMIUM(bool visible) = 0; + // GL_CHROMIUM_gpu_memory_manager - sets callback to observe changes to memory allocation limits. + virtual void setMemoryAllocationChangedCallbackCHROMIUM(WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback) { } + // Query whether it is built on top of compliant GLES2 implementation. virtual bool isGLES2Compliant() = 0; diff --git a/Source/WebKit/chromium/public/platform/WebKitPlatformSupport.h b/Source/WebKit/chromium/public/platform/WebKitPlatformSupport.h index 54795fa48..3bf4cb43a 100644 --- a/Source/WebKit/chromium/public/platform/WebKitPlatformSupport.h +++ b/Source/WebKit/chromium/public/platform/WebKitPlatformSupport.h @@ -240,11 +240,76 @@ public: virtual void decrementStatsCounter(const char* name) { } virtual void incrementStatsCounter(const char* name) { } - // An event is identified by the pair (name, id). The extra parameter - // specifies additional data to log with the event. - virtual bool isTraceEventEnabled() const { return true; } - virtual void traceEventBegin(const char* name, void* id, const char* extra) { } - virtual void traceEventEnd(const char* name, void* id, const char* extra) { } + // Tracing ------------------------------------------------------------- + + // Get a pointer to the enabled state of the given trace category. The + // embedder can dynamically change the enabled state as trace event + // recording is started and stopped by the application. Only long-lived + // literal strings should be given as the category name. The implementation + // expects the returned pointer to be held permanently in a local static. If + // the unsigned char is non-zero, tracing is enabled. If tracing is enabled, + // addTraceEvent is expected to be called by the trace event macros. + virtual const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) { return 0; } + // Add a trace event to the platform tracing system. Depending on the actual + // enabled state, this event may be recorded or dropped. Returns + // thresholdBeginId for use in a corresponding end addTraceEvent call. + // - phase specifies the type of event: + // - BEGIN ('B'): Marks the beginning of a scoped event. + // - END ('E'): Marks the end of a scoped event. + // - INSTANT ('I'): Standalone, instantaneous event. + // - START ('S'): Marks the beginning of an asynchronous event (the end + // event can occur in a different scope or thread). The id parameter is + // used to match START/FINISH pairs. + // - FINISH ('F'): Marks the end of an asynchronous event. + // - COUNTER ('C'): Used to trace integer quantities that change over + // time. The argument values are expected to be of type int. + // - METADATA ('M'): Reserved for internal use. + // - categoryEnabled is the pointer returned by getTraceCategoryEnabledFlag. + // - name is the name of the event. Also used to match BEGIN/END and + // START/FINISH pairs. + // - id optionally allows events of the same name to be distinguished from + // each other. For example, to trace the consutruction and destruction of + // objects, specify the pointer as the id parameter. + // - numArgs specifies the number of elements in argNames, argTypes, and + // argValues. + // - argNames is the array of argument names. Use long-lived literal strings + // or specify the COPY flag. + // - argTypes is the array of argument types: + // - BOOL (1): bool + // - UINT (2): unsigned long long + // - INT (3): long long + // - DOUBLE (4): double + // - POINTER (5): void* + // - STRING (6): char* (long-lived null-terminated char* string) + // - COPY_STRING (7): char* (temporary null-terminated char* string) + // - argValues is the array of argument values. Each value is the unsigned + // long long member of a union of all supported types. + // - thresholdBeginId optionally specifies the value returned by a previous + // call to addTraceEvent with a BEGIN phase. + // - threshold is used on an END phase event in conjunction with the + // thresholdBeginId of a prior BEGIN event. The threshold is the minimum + // number of microseconds that must have passed since the BEGIN event. If + // less than threshold microseconds has passed, the BEGIN/END pair is + // dropped. + // - flags can be 0 or one or more of the following, ORed together: + // - COPY (0x1): treat all strings (name, argNames and argValues of type + // string) as temporary so that they will be copied by addTraceEvent. + // - HAS_ID (0x2): use the id argument to uniquely identify the event for + // matching with other events of the same name. + // - MANGLE_ID (0x4): specify this flag if the id parameter is the value + // of a pointer. + virtual int addTraceEvent( + char phase, + const unsigned char* categoryEnabledFlag, + const char* name, + unsigned long long id, + int numArgs, + const char** argNames, + const unsigned char* argTypes, + const unsigned long long* argValues, + int thresholdBeginId, + long long threshold, + unsigned char flags) { return -1; } // Callbacks for reporting histogram data. // CustomCounts histogram has exponential bucket sizes, so that min=1, max=1000000, bucketCount=50 would do. diff --git a/Source/WebKit/chromium/public/platform/WebLayerTreeView.h b/Source/WebKit/chromium/public/platform/WebLayerTreeView.h index 0263b3926..17a876a98 100644 --- a/Source/WebKit/chromium/public/platform/WebLayerTreeView.h +++ b/Source/WebKit/chromium/public/platform/WebLayerTreeView.h @@ -49,14 +49,18 @@ public: , showFPSCounter(false) , showPlatformLayerTree(false) , refreshRate(0) - , partialSwapEnabled(false) { } + , perTilePainting(false) + , partialSwapEnabled(false) + , threadedAnimationEnabled(false) { } bool acceleratePainting; bool compositeOffscreen; bool showFPSCounter; bool showPlatformLayerTree; double refreshRate; + bool perTilePainting; bool partialSwapEnabled; + bool threadedAnimationEnabled; #if WEBKIT_IMPLEMENTATION operator WebCore::CCSettings() const; #endif @@ -107,6 +111,8 @@ public: operator WTF::PassRefPtr<WebCore::CCLayerTreeHost>() const; #endif + WEBKIT_EXPORT void setNeedsRedraw(); + protected: WebPrivatePtr<WebCore::CCLayerTreeHost> m_private; }; diff --git a/Source/WebKit/chromium/public/platform/WebPeerConnectionHandler.h b/Source/WebKit/chromium/public/platform/WebPeerConnectionHandler.h index 7586abc03..bd2093577 100644 --- a/Source/WebKit/chromium/public/platform/WebPeerConnectionHandler.h +++ b/Source/WebKit/chromium/public/platform/WebPeerConnectionHandler.h @@ -54,7 +54,10 @@ class WebPeerConnectionHandler { public: virtual ~WebPeerConnectionHandler() { } - virtual void initialize(const WebString& serverConfiguration, const WebSecurityOrigin&) = 0; + // DEPRECATED + virtual void initialize(const WebString& serverConfiguration, const WebSecurityOrigin&) { }; + + virtual void initialize(const WebString& serverConfiguration, const WebString& username) { }; virtual void produceInitialOffer(const WebVector<WebMediaStreamDescriptor>& pendingAddStreams) = 0; virtual void handleInitialOffer(const WebString& sdp) = 0; diff --git a/Source/WebKit/chromium/public/platform/WebURLResponse.h b/Source/WebKit/chromium/public/platform/WebURLResponse.h index 8629b849c..8d53eac38 100644 --- a/Source/WebKit/chromium/public/platform/WebURLResponse.h +++ b/Source/WebKit/chromium/public/platform/WebURLResponse.h @@ -50,6 +50,11 @@ class WebURLResponsePrivate; class WebURLResponse { public: + class ExtraData { + public: + virtual ~ExtraData() { } + }; + ~WebURLResponse() { reset(); } WebURLResponse() : m_private(0) { } @@ -174,6 +179,15 @@ public: WEBKIT_EXPORT unsigned short remotePort() const; WEBKIT_EXPORT void setRemotePort(unsigned short); + // Extra data associated with the underlying resource response. Resource + // responses can be copied. If non-null, each copy of a resource response + // holds a pointer to the extra data, and the extra data pointer will be + // deleted when the last resource response is destroyed. Setting the extra + // data pointer will cause the underlying resource response to be + // dissociated from any existing non-null extra data pointer. + WEBKIT_EXPORT ExtraData* extraData() const; + WEBKIT_EXPORT void setExtraData(ExtraData*); + protected: void assign(WebURLResponsePrivate*); diff --git a/Source/WebKit/chromium/src/AssertMatchingEnums.cpp b/Source/WebKit/chromium/src/AssertMatchingEnums.cpp index a451b88a6..3f0875b53 100644 --- a/Source/WebKit/chromium/src/AssertMatchingEnums.cpp +++ b/Source/WebKit/chromium/src/AssertMatchingEnums.cpp @@ -454,9 +454,6 @@ COMPILE_ASSERT_MATCHING_ENUM(WebFileErrorPathExists, FileError::PATH_EXISTS_ERR) COMPILE_ASSERT_MATCHING_ENUM(WebGeolocationError::ErrorPermissionDenied, GeolocationError::PermissionDenied); COMPILE_ASSERT_MATCHING_ENUM(WebGeolocationError::ErrorPositionUnavailable, GeolocationError::PositionUnavailable); -COMPILE_ASSERT_MATCHING_ENUM(WebTextCheckingResult::ErrorSpelling, DocumentMarker::Spelling); -COMPILE_ASSERT_MATCHING_ENUM(WebTextCheckingResult::ErrorGrammar, DocumentMarker::Grammar); - COMPILE_ASSERT_MATCHING_ENUM(WebTextCheckingTypeSpelling, TextCheckingTypeSpelling); COMPILE_ASSERT_MATCHING_ENUM(WebTextCheckingTypeGrammar, TextCheckingTypeGrammar); COMPILE_ASSERT_MATCHING_ENUM(WebTextCheckingTypeLink, TextCheckingTypeLink); diff --git a/Source/WebKit/chromium/src/ChromeClientImpl.cpp b/Source/WebKit/chromium/src/ChromeClientImpl.cpp index fb07b4c10..45a813859 100644 --- a/Source/WebKit/chromium/src/ChromeClientImpl.cpp +++ b/Source/WebKit/chromium/src/ChromeClientImpl.cpp @@ -1018,6 +1018,11 @@ void ChromeClientImpl::numWheelEventHandlersChanged(unsigned numberOfWheelHandle m_webView->numberOfWheelEventHandlersChanged(numberOfWheelHandlers); } +void ChromeClientImpl::numTouchEventHandlersChanged(unsigned numberOfTouchHandlers) +{ + m_webView->numberOfTouchEventHandlersChanged(numberOfTouchHandlers); +} + #if ENABLE(POINTER_LOCK) bool ChromeClientImpl::requestPointerLock() { diff --git a/Source/WebKit/chromium/src/ChromeClientImpl.h b/Source/WebKit/chromium/src/ChromeClientImpl.h index 8fd2488d9..23e02ff3d 100644 --- a/Source/WebKit/chromium/src/ChromeClientImpl.h +++ b/Source/WebKit/chromium/src/ChromeClientImpl.h @@ -204,6 +204,7 @@ public: virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const; virtual void numWheelEventHandlersChanged(unsigned); + virtual void numTouchEventHandlersChanged(unsigned); #if ENABLE(POINTER_LOCK) virtual bool requestPointerLock(); diff --git a/Source/WebKit/chromium/src/EditorClientImpl.cpp b/Source/WebKit/chromium/src/EditorClientImpl.cpp index 04aa719ed..934281a29 100644 --- a/Source/WebKit/chromium/src/EditorClientImpl.cpp +++ b/Source/WebKit/chromium/src/EditorClientImpl.cpp @@ -238,13 +238,11 @@ bool EditorClientImpl::shouldChangeSelectedRange(Range* fromRange, return true; } -bool EditorClientImpl::shouldApplyStyle(CSSStyleDeclaration* style, - Range* range) +bool EditorClientImpl::shouldApplyStyle(StylePropertySet* style, Range* range) { if (m_webView->client()) { // FIXME: Pass a reference to the CSSStyleDeclaration somehow. - return m_webView->client()->shouldApplyStyle(WebString(), - WebRange(range)); + return m_webView->client()->shouldApplyStyle(WebString(), WebRange(range)); } return true; } @@ -731,10 +729,10 @@ void EditorClientImpl::checkSpellingOfString(const UChar* text, int length, *misspellingLength = spellLength; } -void EditorClientImpl::requestCheckingOfString(SpellChecker* sender, int identifier, TextCheckingTypeMask, const String& text) +void EditorClientImpl::requestCheckingOfString(SpellChecker* sender, const WebCore::TextCheckingRequest& request) { if (m_webView->spellCheckClient()) - m_webView->spellCheckClient()->requestCheckingOfText(text, new WebTextCheckingCompletionImpl(identifier, sender)); + m_webView->spellCheckClient()->requestCheckingOfText(request.text(), new WebTextCheckingCompletionImpl(request.sequence(), sender)); } String EditorClientImpl::getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord) diff --git a/Source/WebKit/chromium/src/EditorClientImpl.h b/Source/WebKit/chromium/src/EditorClientImpl.h index 2b577107c..b167b6c2d 100644 --- a/Source/WebKit/chromium/src/EditorClientImpl.h +++ b/Source/WebKit/chromium/src/EditorClientImpl.h @@ -67,7 +67,7 @@ public: virtual bool shouldDeleteRange(WebCore::Range*); virtual bool shouldChangeSelectedRange(WebCore::Range* fromRange, WebCore::Range* toRange, WebCore::EAffinity, bool stillSelecting); - virtual bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*); + virtual bool shouldApplyStyle(WebCore::StylePropertySet*, WebCore::Range*); virtual bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*); virtual void didBeginEditing(); virtual void respondToChangedContents(); @@ -109,7 +109,7 @@ public: virtual void getGuessesForWord(const WTF::String& word, const WTF::String& context, WTF::Vector<WTF::String>& guesses); virtual void willSetInputMethodState(); virtual void setInputMethodState(bool enabled); - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&); + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&); virtual WebCore::TextCheckerClient* textChecker() { return this; } diff --git a/Source/WebKit/chromium/src/Extensions3DChromium.cpp b/Source/WebKit/chromium/src/Extensions3DChromium.cpp index ece0405ae..73397bd2b 100644 --- a/Source/WebKit/chromium/src/Extensions3DChromium.cpp +++ b/Source/WebKit/chromium/src/Extensions3DChromium.cpp @@ -107,6 +107,11 @@ void Extensions3DChromium::setVisibilityCHROMIUM(bool visibility) m_private->setVisibilityCHROMIUM(visibility); } +void Extensions3DChromium::setGpuMemoryAllocationChangedCallbackCHROMIUM(PassOwnPtr<GpuMemoryAllocationChangedCallbackCHROMIUM> callback) +{ + m_private->setGpuMemoryAllocationChangedCallbackCHROMIUM(callback); +} + Platform3DObject Extensions3DChromium::createVertexArrayOES() { return 0; diff --git a/Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp b/Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp index cbbf5c581..c7ac894b0 100644 --- a/Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp +++ b/Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp @@ -85,12 +85,11 @@ namespace WebCore { //---------------------------------------------------------------------- // GraphicsContext3DPrivate -GraphicsContext3DPrivate::GraphicsContext3DPrivate(WebKit::WebViewImpl* webViewImpl, PassOwnPtr<WebKit::WebGraphicsContext3D> webContext, GraphicsContext3D::Attributes attrs) +GraphicsContext3DPrivate::GraphicsContext3DPrivate(PassOwnPtr<WebKit::WebGraphicsContext3D> webContext, bool preserveDrawingBuffer) : m_impl(webContext) - , m_webViewImpl(webViewImpl) , m_initializedAvailableExtensions(false) , m_layerComposited(false) - , m_preserveDrawingBuffer(attrs.preserveDrawingBuffer) + , m_preserveDrawingBuffer(preserveDrawingBuffer) , m_resourceSafety(ResourceSafetyUnknown) #if USE(SKIA) , m_grContext(0) @@ -112,59 +111,19 @@ GraphicsContext3DPrivate::~GraphicsContext3DPrivate() #endif } - -PassOwnPtr<GraphicsContext3DPrivate> GraphicsContext3DPrivate::create(WebKit::WebViewImpl* webViewImpl, PassOwnPtr<WebKit::WebGraphicsContext3D> webContext, GraphicsContext3D::Attributes attrs) -{ - return adoptPtr(new GraphicsContext3DPrivate(webViewImpl, webContext, attrs)); -} - -PassRefPtr<GraphicsContext3D> GraphicsContext3DPrivate::createGraphicsContextFromWebContext(PassOwnPtr<WebKit::WebGraphicsContext3D> webContext, GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle, ThreadUsage threadUsage) +PassRefPtr<GraphicsContext3D> GraphicsContext3DPrivate::createGraphicsContextFromWebContext(PassOwnPtr<WebKit::WebGraphicsContext3D> webContext, GraphicsContext3D::RenderStyle renderStyle, bool preserveDrawingBuffer) { - Chrome* chrome = static_cast<Chrome*>(hostWindow); - WebKit::WebViewImpl* webViewImpl = chrome ? static_cast<WebKit::WebViewImpl*>(chrome->client()->webView()) : 0; + bool renderDirectlyToHostWindow = renderStyle == GraphicsContext3D::RenderDirectlyToHostWindow; - OwnPtr<GraphicsContext3DPrivate> priv = GraphicsContext3DPrivate::create(webViewImpl, webContext, attrs); - if (!priv) - return 0; + RefPtr<GraphicsContext3D> context = adoptRef(new GraphicsContext3D(GraphicsContext3D::Attributes(), 0, renderDirectlyToHostWindow)); - bool renderDirectlyToHostWindow = renderStyle == GraphicsContext3D::RenderDirectlyToHostWindow; - RefPtr<GraphicsContext3D> result = adoptRef(new GraphicsContext3D(attrs, hostWindow, renderDirectlyToHostWindow)); - result->m_private = priv.release(); - return result.release(); + OwnPtr<GraphicsContext3DPrivate> priv = adoptPtr(new GraphicsContext3DPrivate(webContext, preserveDrawingBuffer)); + context->m_private = priv.release(); + return context.release(); } namespace { -PassRefPtr<GraphicsContext3D> createGraphicsContext(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle, GraphicsContext3DPrivate::ThreadUsage threadUsage) -{ - bool renderDirectlyToHostWindow = renderStyle == GraphicsContext3D::RenderDirectlyToHostWindow; - - WebKit::WebGraphicsContext3D::Attributes webAttributes; - webAttributes.alpha = attrs.alpha; - webAttributes.depth = attrs.depth; - webAttributes.stencil = attrs.stencil; - webAttributes.antialias = attrs.antialias; - webAttributes.premultipliedAlpha = attrs.premultipliedAlpha; - webAttributes.canRecoverFromContextLoss = attrs.canRecoverFromContextLoss; - webAttributes.noExtensions = attrs.noExtensions; - webAttributes.shareResources = attrs.shareResources; - webAttributes.forUseOnAnotherThread = threadUsage == GraphicsContext3DPrivate::ForUseOnAnotherThread; - - Chrome* chrome = static_cast<Chrome*>(hostWindow); - WebKit::WebViewImpl* webViewImpl = chrome ? static_cast<WebKit::WebViewImpl*>(chrome->client()->webView()) : 0; - OwnPtr<WebKit::WebGraphicsContext3D> webContext; - if (!webViewImpl || !webViewImpl->client()) { - if (renderDirectlyToHostWindow) - return 0; - webContext = adoptPtr(WebKit::webKitPlatformSupport()->createOffscreenGraphicsContext3D(webAttributes)); - } else - webContext = adoptPtr(webViewImpl->client()->createGraphicsContext3D(webAttributes, renderDirectlyToHostWindow)); - if (!webContext) - return 0; - - return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), attrs, hostWindow, renderStyle, threadUsage); -} - void getDrawingParameters(DrawingBuffer* drawingBuffer, WebKit::WebGraphicsContext3D* graphicsContext3D, Platform3DObject* frameBufferId, int* width, int* height) { @@ -181,11 +140,6 @@ void getDrawingParameters(DrawingBuffer* drawingBuffer, WebKit::WebGraphicsConte } // anonymous namespace -PassRefPtr<GraphicsContext3D> GraphicsContext3DPrivate::createGraphicsContextForAnotherThread(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle) -{ - return createGraphicsContext(attrs, hostWindow, renderStyle, ForUseOnAnotherThread); -} - WebKit::WebGraphicsContext3D* GraphicsContext3DPrivate::extractWebGraphicsContext3D(GraphicsContext3D* context) { if (!context) @@ -200,8 +154,6 @@ PlatformGraphicsContext3D GraphicsContext3DPrivate::platformGraphicsContext3D() Platform3DObject GraphicsContext3DPrivate::platformTexture() const { - ASSERT(m_webViewImpl); - m_impl->setParentContext(m_webViewImpl->graphicsContext3D()); return m_impl->getPlatformTextureId(); } @@ -345,13 +297,6 @@ PassRefPtr<ImageData> GraphicsContext3DPrivate::paintRenderingResultsToImageData return imageData.release(); } -bool GraphicsContext3DPrivate::paintsIntoCanvasBuffer() const -{ - // If the gpu compositor is on then skip the readback and software rendering path. - ASSERT(m_webViewImpl); - return !m_webViewImpl->isAcceleratedCompositingActive(); -} - void GraphicsContext3DPrivate::reshape(int width, int height) { if (width == m_impl->width() && height == m_impl->height()) @@ -1035,11 +980,28 @@ GraphicsContext3D::~GraphicsContext3D() m_private->setContextLostCallback(nullptr); m_private->setErrorMessageCallback(nullptr); m_private->setSwapBuffersCompleteCallbackCHROMIUM(nullptr); + m_private->setGpuMemoryAllocationChangedCallbackCHROMIUM(nullptr); } -PassRefPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle) +PassRefPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3D::Attributes attrs, HostWindow*, GraphicsContext3D::RenderStyle renderStyle) { - return createGraphicsContext(attrs, hostWindow, renderStyle, GraphicsContext3DPrivate::ForUseOnThisThread); + ASSERT(renderStyle != GraphicsContext3D::RenderDirectlyToHostWindow); + + WebKit::WebGraphicsContext3D::Attributes webAttributes; + webAttributes.alpha = attrs.alpha; + webAttributes.depth = attrs.depth; + webAttributes.stencil = attrs.stencil; + webAttributes.antialias = attrs.antialias; + webAttributes.premultipliedAlpha = attrs.premultipliedAlpha; + webAttributes.canRecoverFromContextLoss = attrs.canRecoverFromContextLoss; + webAttributes.noExtensions = attrs.noExtensions; + webAttributes.shareResources = attrs.shareResources; + + OwnPtr<WebKit::WebGraphicsContext3D> webContext = adoptPtr(WebKit::webKitPlatformSupport()->createOffscreenGraphicsContext3D(webAttributes)); + if (!webContext) + return 0; + + return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), renderStyle, attrs.preserveDrawingBuffer); } PlatformGraphicsContext3D GraphicsContext3D::platformGraphicsContext3D() const @@ -1247,11 +1209,6 @@ PassRefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData(Drawin DELEGATE_TO_INTERNAL_1R(paintCompositedResultsToCanvas, CanvasRenderingContext*, bool) -bool GraphicsContext3D::paintsIntoCanvasBuffer() const -{ - return m_private->paintsIntoCanvasBuffer(); -} - DELEGATE_TO_INTERNAL_R(createBuffer, Platform3DObject) DELEGATE_TO_INTERNAL_R(createFramebuffer, Platform3DObject) DELEGATE_TO_INTERNAL_R(createProgram, Platform3DObject) @@ -1359,6 +1316,31 @@ void GraphicsContext3DPrivate::setSwapBuffersCompleteCallbackCHROMIUM(PassOwnPtr m_impl->setSwapBuffersCompleteCallbackCHROMIUM(m_swapBuffersCompleteCallbackAdapter.get()); } +class GraphicsContext3DMemoryAllocationChangedCallbackAdapter : public WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM { +public: + GraphicsContext3DMemoryAllocationChangedCallbackAdapter(PassOwnPtr<Extensions3DChromium::GpuMemoryAllocationChangedCallbackCHROMIUM> cb) + : m_memoryAllocationChangedCallback(cb) + { + } + + virtual ~GraphicsContext3DMemoryAllocationChangedCallbackAdapter() { } + + virtual void onMemoryAllocationChanged(size_t gpuResourceSizeInBytes) + { + if (m_memoryAllocationChangedCallback) + m_memoryAllocationChangedCallback->onGpuMemoryAllocationChanged(gpuResourceSizeInBytes); + } + +private: + OwnPtr<Extensions3DChromium::GpuMemoryAllocationChangedCallbackCHROMIUM> m_memoryAllocationChangedCallback; +}; + +void GraphicsContext3DPrivate::setGpuMemoryAllocationChangedCallbackCHROMIUM(PassOwnPtr<Extensions3DChromium::GpuMemoryAllocationChangedCallbackCHROMIUM> cb) +{ + m_memoryAllocationChangedCallbackAdapter = adoptPtr(new GraphicsContext3DMemoryAllocationChangedCallbackAdapter(cb)); + m_impl->setMemoryAllocationChangedCallbackCHROMIUM(m_memoryAllocationChangedCallbackAdapter.get()); +} + } // namespace WebCore #endif // ENABLE(WEBGL) diff --git a/Source/WebKit/chromium/src/GraphicsContext3DPrivate.h b/Source/WebKit/chromium/src/GraphicsContext3DPrivate.h index f2d49a132..d296eeb9b 100644 --- a/Source/WebKit/chromium/src/GraphicsContext3DPrivate.h +++ b/Source/WebKit/chromium/src/GraphicsContext3DPrivate.h @@ -41,8 +41,7 @@ class GrContext; namespace WebKit { class WebGraphicsContext3D; -class WebViewImpl; -} // namespace WebKit +} namespace WebCore { @@ -51,25 +50,14 @@ class Extensions3DChromium; class GraphicsContextLostCallbackAdapter; class GraphicsContext3DSwapBuffersCompleteCallbackAdapter; class GraphicsErrorMessageCallbackAdapter; +class GraphicsContext3DMemoryAllocationChangedCallbackAdapter; class GraphicsContext3DPrivate { public: - static PassOwnPtr<GraphicsContext3DPrivate> create(WebKit::WebViewImpl*, PassOwnPtr<WebKit::WebGraphicsContext3D>, GraphicsContext3D::Attributes); - - enum ThreadUsage { - ForUseOnThisThread, - ForUseOnAnotherThread, - }; - - // createGraphicsContextForAnotherThread is equivalent to - // GraphicsContext3D::create, but will skip making the context - // current. Callers must make the context current before using it AND check - // that the context was created successfully via ContextLost. Once made - // current on a thread, the context cannot be used on any other thread. - static PassRefPtr<GraphicsContext3D> createGraphicsContextForAnotherThread(GraphicsContext3D::Attributes, HostWindow*, GraphicsContext3D::RenderStyle); - - // Used in tests to create a GraphicsContext3D from a mocked WebGraphicsContext3D. - static PassRefPtr<GraphicsContext3D> createGraphicsContextFromWebContext(PassOwnPtr<WebKit::WebGraphicsContext3D>, GraphicsContext3D::Attributes, HostWindow*, GraphicsContext3D::RenderStyle, ThreadUsage); + // Callers must make the context current before using it AND check that the context was created successfully + // via ContextLost before using the context in any way. Once made current on a thread, the context cannot + // be used on any other thread. + static PassRefPtr<GraphicsContext3D> createGraphicsContextFromWebContext(PassOwnPtr<WebKit::WebGraphicsContext3D>, GraphicsContext3D::RenderStyle, bool preserveDrawingBuffer = false); ~GraphicsContext3DPrivate(); @@ -97,7 +85,6 @@ public: void paintRenderingResultsToCanvas(CanvasRenderingContext*, DrawingBuffer*); void paintFramebufferToCanvas(int framebuffer, int width, int height, bool premultiplyAlpha, ImageBuffer*); PassRefPtr<ImageData> paintRenderingResultsToImageData(DrawingBuffer*); - bool paintsIntoCanvasBuffer() const; bool paintCompositedResultsToCanvas(CanvasRenderingContext*); void prepareTexture(); @@ -295,6 +282,9 @@ public: // GL_CHROMIUM_set_visibility void setVisibilityCHROMIUM(bool); + // GL_CHROMIUM_gpu_memory_manager + void setGpuMemoryAllocationChangedCallbackCHROMIUM(PassOwnPtr<Extensions3DChromium::GpuMemoryAllocationChangedCallbackCHROMIUM>); + // GL_CHROMIUM_framebuffer_multisample void blitFramebufferCHROMIUM(GC3Dint srcX0, GC3Dint srcY0, GC3Dint srcX1, GC3Dint srcY1, GC3Dint dstX0, GC3Dint dstY0, GC3Dint dstX1, GC3Dint dstY1, GC3Dbitfield mask, GC3Denum filter); void renderbufferStorageMultisampleCHROMIUM(GC3Denum target, GC3Dsizei samples, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height); @@ -318,14 +308,14 @@ public: void texStorage2DEXT(GC3Denum target, GC3Dint levels, GC3Duint internalformat, GC3Dint width, GC3Dint height); private: - GraphicsContext3DPrivate(WebKit::WebViewImpl*, PassOwnPtr<WebKit::WebGraphicsContext3D>, GraphicsContext3D::Attributes); + GraphicsContext3DPrivate(PassOwnPtr<WebKit::WebGraphicsContext3D>, bool preserveDrawingBuffer); OwnPtr<WebKit::WebGraphicsContext3D> m_impl; OwnPtr<Extensions3DChromium> m_extensions; OwnPtr<GraphicsContextLostCallbackAdapter> m_contextLostCallbackAdapter; OwnPtr<GraphicsErrorMessageCallbackAdapter> m_errorMessageCallbackAdapter; OwnPtr<GraphicsContext3DSwapBuffersCompleteCallbackAdapter> m_swapBuffersCompleteCallbackAdapter; - WebKit::WebViewImpl* m_webViewImpl; + OwnPtr<GraphicsContext3DMemoryAllocationChangedCallbackAdapter> m_memoryAllocationChangedCallbackAdapter; bool m_initializedAvailableExtensions; HashSet<String> m_enabledExtensions; HashSet<String> m_requestableExtensions; diff --git a/Source/WebKit/chromium/src/IDBFactoryBackendProxy.cpp b/Source/WebKit/chromium/src/IDBFactoryBackendProxy.cpp index 99a0afae4..a1cce45b0 100755 --- a/Source/WebKit/chromium/src/IDBFactoryBackendProxy.cpp +++ b/Source/WebKit/chromium/src/IDBFactoryBackendProxy.cpp @@ -157,6 +157,12 @@ private: bool IDBFactoryBackendProxy::allowIDBFromWorkerThread(WorkerContext* workerContext, const String& name, const WebSecurityOrigin&) { + // FIXME: Bypass checking for permission so as not to block shared worker + // testing until a permissions check is implemented. This has to be fixed + // before m19 goes to beta. http://crbug.com/112855 + if (workerContext->isSharedWorkerContext()) + return true; + WebWorkerClientImpl* webWorkerClientImpl = static_cast<WebWorkerClientImpl*>(&workerContext->thread()->workerLoaderProxy()); WorkerRunLoop& runLoop = workerContext->thread()->runLoop(); @@ -181,15 +187,7 @@ void IDBFactoryBackendProxy::openFromWorker(const String& name, IDBCallbacks* ca callbacks->onError(WebIDBDatabaseError(0, "The user denied permission to access the database.")); return; } - WorkerLoaderProxy* workerLoaderProxy = &context->thread()->workerLoaderProxy(); - WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerLoaderProxy); - WebView* webView = webWorker->view(); - if (!webView) { - // Frame is closed, worker is terminaring. - return; - } - WebFrame* webFrame = webView->mainFrame(); - m_webIDBFactory->open(name, new WebIDBCallbacksImpl(callbacks), origin, webFrame, dataDir); + m_webIDBFactory->open(name, new WebIDBCallbacksImpl(callbacks), origin, /*webFrame*/0, dataDir); #endif } diff --git a/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.cpp b/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.cpp index 71fb571d1..485487ac0 100755 --- a/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.cpp +++ b/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.cpp @@ -98,6 +98,14 @@ void IDBObjectStoreBackendProxy::deleteFunction(PassRefPtr<IDBKey> key, PassRefP m_webIDBObjectStore->deleteFunction(key, new WebIDBCallbacksImpl(callbacks), *transactionProxy->getWebIDBTransaction(), ec); } +void IDBObjectStoreBackendProxy::deleteFunction(PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks, IDBTransactionBackendInterface* transaction, ExceptionCode& ec) +{ + // The transaction pointer is guaranteed to be a pointer to a proxy object as, in the renderer, + // all implementations of IDB interfaces are proxy objects. + IDBTransactionBackendProxy* transactionProxy = static_cast<IDBTransactionBackendProxy*>(transaction); + m_webIDBObjectStore->deleteFunction(keyRange, new WebIDBCallbacksImpl(callbacks), *transactionProxy->getWebIDBTransaction(), ec); +} + void IDBObjectStoreBackendProxy::clear(PassRefPtr<IDBCallbacks> callbacks, IDBTransactionBackendInterface* transaction, ExceptionCode& ec) { // The transaction pointer is guaranteed to be a pointer to a proxy object as, in the renderer, diff --git a/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.h b/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.h index 6d335635c..c19a0f0a4 100644 --- a/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.h +++ b/Source/WebKit/chromium/src/IDBObjectStoreBackendProxy.h @@ -49,6 +49,7 @@ public: virtual void get(PassRefPtr<WebCore::IDBKey>, PassRefPtr<WebCore::IDBCallbacks>, WebCore::IDBTransactionBackendInterface*, WebCore::ExceptionCode&); virtual void put(PassRefPtr<WebCore::SerializedScriptValue>, PassRefPtr<WebCore::IDBKey>, PutMode, PassRefPtr<WebCore::IDBCallbacks>, WebCore::IDBTransactionBackendInterface*, WebCore::ExceptionCode&); virtual void deleteFunction(PassRefPtr<WebCore::IDBKey>, PassRefPtr<WebCore::IDBCallbacks>, WebCore::IDBTransactionBackendInterface*, WebCore::ExceptionCode&); + virtual void deleteFunction(PassRefPtr<WebCore::IDBKeyRange>, PassRefPtr<WebCore::IDBCallbacks>, WebCore::IDBTransactionBackendInterface*, WebCore::ExceptionCode&); virtual void clear(PassRefPtr<WebCore::IDBCallbacks>, WebCore::IDBTransactionBackendInterface*, WebCore::ExceptionCode&); PassRefPtr<WebCore::IDBIndexBackendInterface> createIndex(const String& name, const String& keyPath, bool unique, bool multiEntry, WebCore::IDBTransactionBackendInterface*, WebCore::ExceptionCode&); diff --git a/Source/WebKit/chromium/src/NonCompositedContentHost.cpp b/Source/WebKit/chromium/src/NonCompositedContentHost.cpp index c9be08a84..b6b1a2294 100644 --- a/Source/WebKit/chromium/src/NonCompositedContentHost.cpp +++ b/Source/WebKit/chromium/src/NonCompositedContentHost.cpp @@ -27,6 +27,7 @@ #include "NonCompositedContentHost.h" +#include "FloatPoint.h" #include "FloatRect.h" #include "GraphicsLayer.h" #include "LayerChromium.h" @@ -103,6 +104,7 @@ void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, m_viewportSize = viewportSize; scrollLayer()->setScrollPosition(scrollPosition); + scrollLayer()->setPosition(-scrollPosition); // Due to the possibility of pinch zoom, the noncomposited layer is always // assumed to be scrollable. scrollLayer()->setScrollable(true); diff --git a/Source/WebKit/chromium/src/PlatformSupport.cpp b/Source/WebKit/chromium/src/PlatformSupport.cpp index b4d479ca6..63be0245c 100644 --- a/Source/WebKit/chromium/src/PlatformSupport.cpp +++ b/Source/WebKit/chromium/src/PlatformSupport.cpp @@ -947,19 +947,24 @@ void PlatformSupport::paintThemePart( // Trace Event ---------------------------------------------------------------- -bool PlatformSupport::isTraceEventEnabled() -{ - return webKitPlatformSupport()->isTraceEventEnabled(); -} - -void PlatformSupport::traceEventBegin(const char* name, void* id, const char* extra) -{ - webKitPlatformSupport()->traceEventBegin(name, id, extra); -} - -void PlatformSupport::traceEventEnd(const char* name, void* id, const char* extra) -{ - webKitPlatformSupport()->traceEventEnd(name, id, extra); +const unsigned char* PlatformSupport::getTraceCategoryEnabledFlag(const char* categoryName) +{ + return webKitPlatformSupport()->getTraceCategoryEnabledFlag(categoryName); +} +int PlatformSupport::addTraceEvent(char phase, + const unsigned char* categoryEnabledFlag, + const char* name, + unsigned long long id, + int numArgs, + const char** argNames, + const unsigned char* argTypes, + const unsigned long long* argValues, + int thresholdBeginId, + long long threshold, + unsigned char flags) +{ + return webKitPlatformSupport()->addTraceEvent( + phase, categoryEnabledFlag, name, id, numArgs, argNames, argTypes, argValues, thresholdBeginId, threshold, flags); } // Visited Links -------------------------------------------------------------- diff --git a/Source/WebKit/chromium/src/SocketStreamHandle.cpp b/Source/WebKit/chromium/src/SocketStreamHandle.cpp index cf8aa02cd..298e733a4 100644 --- a/Source/WebKit/chromium/src/SocketStreamHandle.cpp +++ b/Source/WebKit/chromium/src/SocketStreamHandle.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 Google Inc. All rights reserved. + * Copyright (C) 2009, 2012 Google Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -30,6 +30,7 @@ #include "config.h" #include "SocketStreamHandle.h" +#include "SocketStreamHandleInternal.h" #if ENABLE(WEB_SOCKETS) @@ -40,41 +41,12 @@ #include "WebKit.h" #include "platform/WebKitPlatformSupport.h" #include "platform/WebSocketStreamHandle.h" -#include "platform/WebSocketStreamHandleClient.h" -#include "platform/WebURL.h" #include <wtf/PassOwnPtr.h> using namespace WebKit; namespace WebCore { -class SocketStreamHandleInternal : public WebSocketStreamHandleClient { -public: - static PassOwnPtr<SocketStreamHandleInternal> create(SocketStreamHandle* handle) - { - return adoptPtr(new SocketStreamHandleInternal(handle)); - } - virtual ~SocketStreamHandleInternal(); - - void connect(const KURL&); - int send(const char*, int); - void close(); - - virtual void didOpenStream(WebSocketStreamHandle*, int); - virtual void didSendData(WebSocketStreamHandle*, int); - virtual void didReceiveData(WebSocketStreamHandle*, const WebData&); - virtual void didClose(WebSocketStreamHandle*); - virtual void didFail(WebSocketStreamHandle*, const WebSocketStreamError&); - -private: - explicit SocketStreamHandleInternal(SocketStreamHandle*); - - SocketStreamHandle* m_handle; - OwnPtr<WebSocketStreamHandle> m_socket; - int m_maxPendingSendAllowed; - int m_pendingAmountSent; -}; - SocketStreamHandleInternal::SocketStreamHandleInternal(SocketStreamHandle* handle) : m_handle(handle) , m_maxPendingSendAllowed(0) diff --git a/Source/WebKit/chromium/src/SocketStreamHandleInternal.h b/Source/WebKit/chromium/src/SocketStreamHandleInternal.h new file mode 100644 index 000000000..857b279e7 --- /dev/null +++ b/Source/WebKit/chromium/src/SocketStreamHandleInternal.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SocketStreamHandleInternal_h +#define SocketStreamHandleInternal_h + +#if ENABLE(WEB_SOCKETS) + +#include "SocketStreamHandle.h" +#include "platform/WebSocketStreamHandleClient.h" +#include "platform/WebURL.h" +#include <wtf/PassOwnPtr.h> + +namespace WebKit { + +class WebData; +class WebSocketStreamError; +class WebSocketStreamHandle; + +} + +namespace WebCore { + +class SocketStreamHandleInternal : public WebKit::WebSocketStreamHandleClient { +public: + static PassOwnPtr<SocketStreamHandleInternal> create(SocketStreamHandle* handle) + { + return adoptPtr(new SocketStreamHandleInternal(handle)); + } + virtual ~SocketStreamHandleInternal(); + + void connect(const KURL&); + int send(const char*, int); + void close(); + + virtual void didOpenStream(WebKit::WebSocketStreamHandle*, int); + virtual void didSendData(WebKit::WebSocketStreamHandle*, int); + virtual void didReceiveData(WebKit::WebSocketStreamHandle*, const WebKit::WebData&); + virtual void didClose(WebKit::WebSocketStreamHandle*); + virtual void didFail(WebKit::WebSocketStreamHandle*, const WebKit::WebSocketStreamError&); + + static WebKit::WebSocketStreamHandle* toWebSocketStreamHandle(SocketStreamHandle* handle) + { + if (handle && handle->m_internal) + return handle->m_internal->m_socket.get(); + return 0; + } + +private: + explicit SocketStreamHandleInternal(SocketStreamHandle*); + + SocketStreamHandle* m_handle; + OwnPtr<WebKit::WebSocketStreamHandle> m_socket; + int m_maxPendingSendAllowed; + int m_pendingAmountSent; +}; + +} // namespace WebCore + +#endif // ENABLE(WEB_SOCKETS) + +#endif // SocketStreamHandleInternal_h diff --git a/Source/WebKit/chromium/src/UserMediaClientImpl.h b/Source/WebKit/chromium/src/UserMediaClientImpl.h index f6ab0416b..a1c6ac281 100644 --- a/Source/WebKit/chromium/src/UserMediaClientImpl.h +++ b/Source/WebKit/chromium/src/UserMediaClientImpl.h @@ -31,6 +31,8 @@ #ifndef UserMediaClientImpl_h #define UserMediaClientImpl_h +#if ENABLE(MEDIA_STREAM) + #include "MediaStreamSource.h" #include "UserMediaClient.h" #include <wtf/PassRefPtr.h> @@ -61,4 +63,6 @@ private: } // namespace WebKit +#endif // ENABLE(MEDIA_STREAM) + #endif // UserMediaClientImpl_h diff --git a/Source/WebKit/chromium/src/VideoFrameChromiumImpl.cpp b/Source/WebKit/chromium/src/VideoFrameChromiumImpl.cpp index ce389adc6..fcce939f7 100644 --- a/Source/WebKit/chromium/src/VideoFrameChromiumImpl.cpp +++ b/Source/WebKit/chromium/src/VideoFrameChromiumImpl.cpp @@ -128,4 +128,11 @@ unsigned VideoFrameChromiumImpl::textureId() const return 0; } +unsigned VideoFrameChromiumImpl::textureTarget() const +{ + if (m_webVideoFrame) + return m_webVideoFrame->textureTarget(); + return 0; +} + } // namespace WebKit diff --git a/Source/WebKit/chromium/src/VideoFrameChromiumImpl.h b/Source/WebKit/chromium/src/VideoFrameChromiumImpl.h index 446ab5f54..67920866f 100644 --- a/Source/WebKit/chromium/src/VideoFrameChromiumImpl.h +++ b/Source/WebKit/chromium/src/VideoFrameChromiumImpl.h @@ -58,6 +58,7 @@ public: virtual const WebCore::IntSize requiredTextureSize(unsigned plane) const; virtual bool hasPaddingBytes(unsigned plane) const; virtual unsigned textureId() const; + virtual unsigned textureTarget() const; private: WebVideoFrame* m_webVideoFrame; diff --git a/Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.cpp b/Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.cpp index 40c151dfd..397308b52 100644 --- a/Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.cpp +++ b/Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.cpp @@ -121,9 +121,9 @@ void WebCompositorInputHandlerImpl::handleInputEvent(const WebInputEvent& event) ASSERT(CCProxy::isImplThread()); ASSERT(m_client); - if (event.type == WebInputEvent::MouseWheel && !m_inputHandlerClient->haveWheelEventHandlers()) { + if (event.type == WebInputEvent::MouseWheel) { const WebMouseWheelEvent& wheelEvent = *static_cast<const WebMouseWheelEvent*>(&event); - CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(wheelEvent.x, wheelEvent.y)); + CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(wheelEvent.x, wheelEvent.y), CCInputHandlerClient::Wheel); switch (scrollStatus) { case CCInputHandlerClient::ScrollStarted: m_inputHandlerClient->scrollBy(IntSize(-wheelEvent.deltaX, -wheelEvent.deltaY)); @@ -143,7 +143,7 @@ void WebCompositorInputHandlerImpl::handleInputEvent(const WebInputEvent& event) m_expectScrollUpdateEnd = true; #endif const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event); - CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(gestureEvent.x, gestureEvent.y)); + CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(gestureEvent.x, gestureEvent.y), CCInputHandlerClient::Gesture); switch (scrollStatus) { case CCInputHandlerClient::ScrollStarted: m_scrollStarted = true; diff --git a/Source/WebKit/chromium/src/WebDatabase.cpp b/Source/WebKit/chromium/src/WebDatabase.cpp index 9545a07e0..9ea6ee9b5 100644 --- a/Source/WebKit/chromium/src/WebDatabase.cpp +++ b/Source/WebKit/chromium/src/WebDatabase.cpp @@ -122,10 +122,7 @@ void WebDatabase::resetSpaceAvailable(const WebString& originIdentifier) void WebDatabase::closeDatabaseImmediately(const WebString& originIdentifier, const WebString& databaseName) { #if ENABLE(SQL_DATABASE) - HashSet<RefPtr<AbstractDatabase> > databaseHandles; - DatabaseTracker::tracker().getOpenDatabases(originIdentifier, databaseName, &databaseHandles); - for (HashSet<RefPtr<AbstractDatabase> >::iterator it = databaseHandles.begin(); it != databaseHandles.end(); ++it) - it->get()->closeImmediately(); + DatabaseTracker::tracker().closeDatabasesImmediately(originIdentifier, databaseName); #endif } diff --git a/Source/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp b/Source/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp index dc126f0f5..054e5b245 100644 --- a/Source/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp +++ b/Source/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp @@ -31,7 +31,6 @@ #include "config.h" #include "WebDevToolsFrontendImpl.h" -#include "BoundObject.h" #include "ContextMenuController.h" #include "ContextMenuItem.h" #include "DOMWindow.h" diff --git a/Source/WebKit/chromium/src/WebDragData.cpp b/Source/WebKit/chromium/src/WebDragData.cpp index 5c3123918..9e634340e 100644 --- a/Source/WebKit/chromium/src/WebDragData.cpp +++ b/Source/WebKit/chromium/src/WebDragData.cpp @@ -66,166 +66,88 @@ void WebDragData::assign(const WebDragData& other) assign(p); } -WebString WebDragData::url() const -{ - ASSERT(!isNull()); - bool ignoredSuccess; - return m_private->getData(mimeTypeURL, ignoredSuccess); -} - -void WebDragData::setURL(const WebURL& url) -{ - ensureMutable(); - m_private->setData(mimeTypeURL, KURL(url).string()); -} - -WebString WebDragData::urlTitle() const -{ - ASSERT(!isNull()); - return m_private->urlTitle(); -} - -void WebDragData::setURLTitle(const WebString& urlTitle) -{ - ensureMutable(); - m_private->setUrlTitle(urlTitle); -} - -WebString WebDragData::downloadMetadata() const -{ - ASSERT(!isNull()); - bool ignoredSuccess; - return m_private->getData(mimeTypeDownloadURL, ignoredSuccess); -} - -void WebDragData::setDownloadMetadata(const WebString& downloadMetadata) -{ - ensureMutable(); - m_private->setData(mimeTypeDownloadURL, downloadMetadata); -} - -WebString WebDragData::fileExtension() const -{ - ASSERT(!isNull()); - return m_private->fileExtension(); -} - -void WebDragData::setFileExtension(const WebString& fileExtension) -{ - ensureMutable(); - m_private->setFileExtension(fileExtension); -} - -bool WebDragData::containsFilenames() const -{ - ASSERT(!isNull()); - return m_private->containsFilenames(); -} - -void WebDragData::filenames(WebVector<WebString>& filenames) const -{ - ASSERT(!isNull()); - filenames = m_private->filenames(); -} - -void WebDragData::setFilenames(const WebVector<WebString>& filenames) -{ - ensureMutable(); - Vector<String> filenamesCopy; - filenamesCopy.append(filenames.data(), filenames.size()); - m_private->setFilenames(filenamesCopy); -} - -void WebDragData::appendToFilenames(const WebString& filename) -{ - ensureMutable(); - Vector<String> filenames = m_private->filenames(); - filenames.append(filename); - m_private->setFilenames(filenames); -} - -WebString WebDragData::plainText() const -{ - ASSERT(!isNull()); - bool ignoredSuccess; - return m_private->getData(mimeTypeTextPlain, ignoredSuccess); -} - -void WebDragData::setPlainText(const WebString& plainText) -{ - ensureMutable(); - m_private->setData(mimeTypeTextPlain, plainText); -} - -WebString WebDragData::htmlText() const -{ - ASSERT(!isNull()); - bool ignoredSuccess; - return m_private->getData(mimeTypeTextHTML, ignoredSuccess); -} - -void WebDragData::setHTMLText(const WebString& htmlText) -{ - ensureMutable(); - m_private->setData(mimeTypeTextHTML, htmlText); -} - -WebURL WebDragData::htmlBaseURL() const -{ - ASSERT(!isNull()); - return m_private->htmlBaseUrl(); -} - -void WebDragData::setHTMLBaseURL(const WebURL& htmlBaseURL) -{ - ensureMutable(); - m_private->setHtmlBaseUrl(htmlBaseURL); -} - -WebString WebDragData::fileContentFilename() const -{ - ASSERT(!isNull()); - return m_private->fileContentFilename(); -} - -void WebDragData::setFileContentFilename(const WebString& filename) -{ - ensureMutable(); - m_private->setFileContentFilename(filename); +WebVector<WebDragData::Item> WebDragData::items() const +{ + Vector<Item> itemList; + RefPtr<DOMStringList> types = m_private->types(); + if (types->contains(mimeTypeTextPlain)) { + Item item; + item.storageType = Item::StorageTypeString; + item.stringType = String(mimeTypeTextPlain); + bool ignored; + item.stringData = m_private->getData(mimeTypeTextPlain, ignored); + itemList.append(item); + } + if (types->contains(mimeTypeTextURIList)) { + Item item; + item.storageType = Item::StorageTypeString; + item.stringType = String(mimeTypeTextURIList); + bool ignored; + item.stringData = m_private->getData(mimeTypeURL, ignored); + item.title = m_private->urlTitle(); + itemList.append(item); + } + if (types->contains(mimeTypeTextHTML)) { + Item item; + item.storageType = Item::StorageTypeString; + item.stringType = String(mimeTypeTextHTML); + bool ignored; + item.stringData = m_private->getData(mimeTypeTextHTML, ignored); + item.baseURL = m_private->htmlBaseUrl(); + itemList.append(item); + } + if (types->contains(mimeTypeDownloadURL)) { + Item item; + item.storageType = Item::StorageTypeString; + item.stringType = String(mimeTypeDownloadURL); + bool ignored; + item.stringData = m_private->getData(mimeTypeDownloadURL, ignored); + itemList.append(item); + } + const HashMap<String, String>& customData = m_private->customData(); + for (HashMap<String, String>::const_iterator it = customData.begin(); it != customData.end(); ++it) { + Item item; + item.storageType = Item::StorageTypeString; + item.stringType = it->first; + item.stringData = it->second; + itemList.append(item); + } + if (m_private->fileContent()) { + Item item; + item.storageType = Item::StorageTypeBinaryData; + item.binaryData = m_private->fileContent(); + item.title = m_private->fileContentFilename(); + itemList.append(item); + } + // We don't handle filenames here, since they are never used for dragging out. + return itemList; } -WebData WebDragData::fileContent() const +void WebDragData::setItems(const WebVector<Item>& itemList) { - ASSERT(!isNull()); - return WebData(m_private->fileContent()); + m_private->clearAll(); + for (size_t i = 0; i < itemList.size(); ++i) + addItem(itemList[i]); } -void WebDragData::setFileContent(const WebData& fileContent) +void WebDragData::addItem(const Item& item) { ensureMutable(); - m_private->setFileContent(fileContent); -} - -WebVector<WebDragData::CustomData> WebDragData::customData() const -{ - ASSERT(!isNull()); - WebVector<CustomData> customData(static_cast<size_t>(m_private->customData().size())); - HashMap<String, String>::const_iterator begin = m_private->customData().begin(); - HashMap<String, String>::const_iterator end = m_private->customData().end(); - size_t i = 0; - for (HashMap<String, String>::const_iterator it = begin; it != end; ++it) { - CustomData data = {it->first, it->second}; - customData[i++] = data; + switch (item.storageType) { + case Item::StorageTypeString: + m_private->setData(item.stringType, item.stringData); + if (String(item.stringType) == mimeTypeTextURIList) + m_private->setUrlTitle(item.title); + else if (String(item.stringType) == mimeTypeTextHTML) + m_private->setHtmlBaseUrl(item.baseURL); + return; + case Item::StorageTypeFilename: + m_private->addFilename(item.filenameData); + return; + case Item::StorageTypeBinaryData: + // This should never happen when dragging in. + ASSERT_NOT_REACHED(); } - return customData; -} - -void WebDragData::setCustomData(const WebVector<WebDragData::CustomData>& customData) -{ - ensureMutable(); - HashMap<String, String>& customDataMap = m_private->customData(); - for (size_t i = 0; i < customData.size(); ++i) - customDataMap.set(customData[i].type, customData[i].data); } WebDragData::WebDragData(const WTF::PassRefPtr<WebCore::ChromiumDataObject>& data) diff --git a/Source/WebKit/chromium/src/WebFrameImpl.cpp b/Source/WebKit/chromium/src/WebFrameImpl.cpp index f8d2034fd..adf202371 100644 --- a/Source/WebKit/chromium/src/WebFrameImpl.cpp +++ b/Source/WebKit/chromium/src/WebFrameImpl.cpp @@ -123,8 +123,6 @@ #include "ReplaceSelectionCommand.h" #include "ResourceHandle.h" #include "ResourceRequest.h" -#include "SVGDocumentExtensions.h" -#include "SVGSMILElement.h" #include "SchemeRegistry.h" #include "ScriptController.h" #include "ScriptSourceCode.h" @@ -1303,7 +1301,7 @@ void WebFrameImpl::requestTextChecking(const WebElement& webElem) RefPtr<Range> rangeToCheck = rangeOfContents(const_cast<Element*>(webElem.constUnwrap<Element>())); - frame()->editor()->spellChecker()->requestCheckingFor(SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, rangeToCheck, rangeToCheck)); + frame()->editor()->spellChecker()->requestCheckingFor(SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, TextCheckingProcessBatch, rangeToCheck, rangeToCheck)); } bool WebFrameImpl::hasSelection() const @@ -1946,26 +1944,6 @@ bool WebFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) cons return m_frame->editor()->selectionStartHasMarkerFor(DocumentMarker::Spelling, from, length); } -bool WebFrameImpl::pauseSVGAnimation(const WebString& animationId, double time, const WebString& elementId) -{ -#if !ENABLE(SVG) - return false; -#else - if (!m_frame) - return false; - - Document* document = m_frame->document(); - if (!document || !document->svgExtensions()) - return false; - - Node* coreNode = document->getElementById(animationId); - if (!coreNode || !SVGSMILElement::isSMILElement(coreNode)) - return false; - - return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time); -#endif -} - WebString WebFrameImpl::layerTreeAsText(bool showDebugInfo) const { if (!m_frame) diff --git a/Source/WebKit/chromium/src/WebFrameImpl.h b/Source/WebKit/chromium/src/WebFrameImpl.h index de38d0dca..700f6ea40 100644 --- a/Source/WebKit/chromium/src/WebFrameImpl.h +++ b/Source/WebKit/chromium/src/WebFrameImpl.h @@ -214,9 +214,6 @@ public: virtual WebRect selectionBoundsRect() const; virtual bool selectionStartHasSpellingMarkerFor(int from, int length) const; - virtual bool pauseSVGAnimation(const WebString& animationId, - double time, - const WebString& elementId); virtual WebString layerTreeAsText(bool showDebugInfo = false) const; static PassRefPtr<WebFrameImpl> create(WebFrameClient* client); diff --git a/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.cpp b/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.cpp index 1ec8af5bc..55a6add57 100755 --- a/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.cpp +++ b/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.cpp @@ -82,6 +82,11 @@ void WebIDBObjectStoreImpl::deleteFunction(const WebIDBKey& key, WebIDBCallbacks m_objectStore->deleteFunction(key, IDBCallbacksProxy::create(adoptPtr(callbacks)), transaction.getIDBTransactionBackendInterface(), ec); } +void WebIDBObjectStoreImpl::deleteFunction(const WebIDBKeyRange& keyRange, WebIDBCallbacks* callbacks, const WebIDBTransaction& transaction, WebExceptionCode& ec) +{ + m_objectStore->deleteFunction(keyRange, IDBCallbacksProxy::create(adoptPtr(callbacks)), transaction.getIDBTransactionBackendInterface(), ec); +} + void WebIDBObjectStoreImpl::clear(WebIDBCallbacks* callbacks, const WebIDBTransaction& transaction, WebExceptionCode& ec) { m_objectStore->clear(IDBCallbacksProxy::create(adoptPtr(callbacks)), transaction.getIDBTransactionBackendInterface(), ec); diff --git a/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.h b/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.h index 6f580f01a..d2202fc7f 100644 --- a/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.h +++ b/Source/WebKit/chromium/src/WebIDBObjectStoreImpl.h @@ -51,7 +51,8 @@ public: void get(const WebIDBKey& key, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&); void put(const WebSerializedScriptValue&, const WebIDBKey&, PutMode, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&); - void deleteFunction(const WebIDBKey& key, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&); + void deleteFunction(const WebIDBKey&, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&); + void deleteFunction(const WebIDBKeyRange&, WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&); void clear(WebIDBCallbacks*, const WebIDBTransaction&, WebExceptionCode&); // FIXME: Remove once callers are updated. diff --git a/Source/WebKit/chromium/src/WebInputElement.cpp b/Source/WebKit/chromium/src/WebInputElement.cpp index 5dadb0cf8..736165bbf 100644 --- a/Source/WebKit/chromium/src/WebInputElement.cpp +++ b/Source/WebKit/chromium/src/WebInputElement.cpp @@ -90,7 +90,7 @@ int WebInputElement::size() const void WebInputElement::setValue(const WebString& value, bool sendChangeEvent) { - unwrap<HTMLInputElement>()->setValue(value, sendChangeEvent); + unwrap<HTMLInputElement>()->setValue(value, sendChangeEvent ? DispatchChangeEvent : DispatchNoEvent); } WebString WebInputElement::value() const diff --git a/Source/WebKit/chromium/src/WebInputEventConversion.cpp b/Source/WebKit/chromium/src/WebInputEventConversion.cpp index 64ba31170..5cf0ccaec 100644 --- a/Source/WebKit/chromium/src/WebInputEventConversion.cpp +++ b/Source/WebKit/chromium/src/WebInputEventConversion.cpp @@ -389,6 +389,10 @@ WebMouseEventBuilder::WebMouseEventBuilder(const Widget* widget, const MouseEven windowY = p.y(); x = event.absoluteLocation().x() - widget->location().x(); y = event.absoluteLocation().y() - widget->location().y(); +#if ENABLE(POINTER_LOCK) + movementX = event.webkitMovementX(); + movementY = event.webkitMovementY(); +#endif clickCount = event.detail(); } diff --git a/Source/WebKit/chromium/src/WebKit.cpp b/Source/WebKit/chromium/src/WebKit.cpp index 2b2b2597c..77858c4e7 100644 --- a/Source/WebKit/chromium/src/WebKit.cpp +++ b/Source/WebKit/chromium/src/WebKit.cpp @@ -45,6 +45,10 @@ #include "WorkerContextExecutionProxy.h" #include "v8.h" +#if OS(DARWIN) +#include "WebSystemInterface.h" +#endif + #include <wtf/Assertions.h> #include <wtf/MainThread.h> #include <wtf/Threading.h> @@ -107,6 +111,10 @@ void initializeWithoutV8(WebKitPlatformSupport* webKitPlatformSupport) ASSERT(!s_webKitInitialized); s_webKitInitialized = true; +#if OS(DARWIN) + InitWebCoreSystemInterface(); +#endif + ASSERT(webKitPlatformSupport); ASSERT(!s_webKitPlatformSupport); s_webKitPlatformSupport = webKitPlatformSupport; diff --git a/Source/WebKit/chromium/src/WebLayerTreeView.cpp b/Source/WebKit/chromium/src/WebLayerTreeView.cpp index b288b563b..d2c0f0c12 100644 --- a/Source/WebKit/chromium/src/WebLayerTreeView.cpp +++ b/Source/WebKit/chromium/src/WebLayerTreeView.cpp @@ -43,11 +43,11 @@ WebLayerTreeView::Settings::operator CCSettings() const settings.showFPSCounter = showFPSCounter; settings.showPlatformLayerTree = showPlatformLayerTree; settings.refreshRate = refreshRate; + settings.perTilePainting = perTilePainting; settings.partialSwapEnabled = partialSwapEnabled; + settings.threadedAnimationEnabled = threadedAnimationEnabled; - // FIXME: showFPSCounter / showPlatformLayerTree aren't supported currently. - settings.showFPSCounter = false; - settings.showPlatformLayerTree = false; + // FIXME: showFPSCounter / showPlatformLayerTree / maxPartialTextureUpdates aren't supported currently. return settings; } @@ -118,4 +118,9 @@ WebLayerTreeView::operator PassRefPtr<CCLayerTreeHost>() const return m_private.get(); } +void WebLayerTreeView::setNeedsRedraw() +{ + m_private->setNeedsRedraw(); +} + } // namespace WebKit diff --git a/Source/WebKit/chromium/src/WebLayerTreeViewImpl.cpp b/Source/WebKit/chromium/src/WebLayerTreeViewImpl.cpp index 981477118..29d033215 100644 --- a/Source/WebKit/chromium/src/WebLayerTreeViewImpl.cpp +++ b/Source/WebKit/chromium/src/WebLayerTreeViewImpl.cpp @@ -86,21 +86,7 @@ PassRefPtr<GraphicsContext3D> WebLayerTreeViewImpl::createLayerTreeHostContext3D if (!webContext) return 0; - WebGraphicsContext3D::Attributes webAttributes = webContext->getContextAttributes(); - GraphicsContext3D::Attributes attributes; - attributes.alpha = webAttributes.alpha; - attributes.depth = webAttributes.depth; - attributes.stencil = webAttributes.stencil; - attributes.antialias = webAttributes.antialias; - attributes.premultipliedAlpha = webAttributes.premultipliedAlpha; - attributes.canRecoverFromContextLoss = webAttributes.canRecoverFromContextLoss; - attributes.noExtensions = webAttributes.noExtensions; - attributes.shareResources = webAttributes.shareResources; - attributes.preserveDrawingBuffer = false; - - GraphicsContext3D::RenderStyle style = GraphicsContext3D::RenderDirectlyToHostWindow; - GraphicsContext3DPrivate::ThreadUsage usage = CCProxy::hasImplThread() ? GraphicsContext3DPrivate::ForUseOnAnotherThread : GraphicsContext3DPrivate::ForUseOnThisThread; - return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), attributes, 0, style, usage); + return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), GraphicsContext3D::RenderDirectlyToHostWindow, false /* preserveDrawingBuffer */ ); } void WebLayerTreeViewImpl::didCommitAndDrawFrame() diff --git a/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp b/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp index 996e70710..ec74b6bea 100644 --- a/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp +++ b/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp @@ -28,6 +28,7 @@ #include "WebMediaElement.h" #include "WebMediaPlayer.h" #include "WebViewImpl.h" +#include "cc/CCProxy.h" #include "platform/WebCString.h" #include "platform/WebCanvas.h" #include "platform/WebKitPlatformSupport.h" @@ -105,6 +106,8 @@ WebMediaPlayerClientImpl::~WebMediaPlayerClientImpl() MutexLocker locker(m_compositingMutex); if (m_videoFrameProviderClient) m_videoFrameProviderClient->stopUsingProvider(); + if (m_webMediaPlayer) + m_webMediaPlayer->setStreamTextureClient(0); #endif } @@ -149,7 +152,7 @@ void WebMediaPlayerClientImpl::repaint() ASSERT(m_mediaPlayer); #if USE(ACCELERATED_COMPOSITING) if (m_videoLayer && supportsAcceleratedRendering()) - m_videoLayer->setNeedsDisplay(); + m_videoLayer->contentChanged(); #endif m_mediaPlayer->repaint(); } @@ -237,6 +240,7 @@ void WebMediaPlayerClientImpl::load(const String& url) m_url = url; if (m_preload == MediaPlayer::None) { + MutexLocker locker(m_compositingMutex); #if ENABLE(WEB_AUDIO) m_audioSourceProvider.wrap(0); // Clear weak reference to m_webMediaPlayer's WebAudioSourceProvider. #endif @@ -248,6 +252,7 @@ void WebMediaPlayerClientImpl::load(const String& url) void WebMediaPlayerClientImpl::loadInternal() { + MutexLocker locker(m_compositingMutex); #if ENABLE(WEB_AUDIO) m_audioSourceProvider.wrap(0); // Clear weak reference to m_webMediaPlayer's WebAudioSourceProvider. #endif @@ -597,6 +602,8 @@ void WebMediaPlayerClientImpl::setVideoFrameProviderClient(VideoFrameProvider::C { MutexLocker locker(m_compositingMutex); m_videoFrameProviderClient = client; + if (m_webMediaPlayer) + m_webMediaPlayer->setStreamTextureClient(client ? this : 0); } VideoFrameChromium* WebMediaPlayerClientImpl::getCurrentFrame() @@ -679,6 +686,20 @@ void WebMediaPlayerClientImpl::startDelayedLoad() loadInternal(); } +void WebMediaPlayerClientImpl::didReceiveFrame() +{ + // No lock since this gets called on the client's thread. + ASSERT(CCProxy::isImplThread()); + m_videoFrameProviderClient->didReceiveFrame(); +} + +void WebMediaPlayerClientImpl::didUpdateMatrix(const float* matrix) +{ + // No lock since this gets called on the client's thread. + ASSERT(CCProxy::isImplThread()); + m_videoFrameProviderClient->didUpdateMatrix(matrix); +} + WebMediaPlayerClientImpl::WebMediaPlayerClientImpl() : m_mediaPlayer(0) , m_delayingLoad(false) diff --git a/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.h b/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.h index e75e73ae1..d85e0d1fc 100644 --- a/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.h +++ b/Source/WebKit/chromium/src/WebMediaPlayerClientImpl.h @@ -40,7 +40,9 @@ #include "VideoLayerChromium.h" #include "WebAudioSourceProviderClient.h" #include "WebMediaPlayerClient.h" +#include "WebStreamTextureClient.h" #include <wtf/OwnPtr.h> +#include <wtf/PassOwnPtr.h> namespace WebCore { class AudioSourceProviderClient; } @@ -56,7 +58,8 @@ class WebMediaPlayerClientImpl : public WebCore::MediaPlayerPrivateInterface #if USE(ACCELERATED_COMPOSITING) , public WebCore::VideoFrameProvider #endif - , public WebMediaPlayerClient { + , public WebMediaPlayerClient + , public WebStreamTextureClient { public: static bool isEnabled(); @@ -150,6 +153,10 @@ public: virtual void sourceEndOfStream(WebCore::MediaPlayer::EndOfStreamStatus); #endif + // WebStreamTextureClient methods: + virtual void didReceiveFrame(); + virtual void didUpdateMatrix(const float*); + private: WebMediaPlayerClientImpl(); void startDelayedLoad(); diff --git a/Source/WebKit/chromium/src/WebPageSerializerImpl.cpp b/Source/WebKit/chromium/src/WebPageSerializerImpl.cpp index ca0583488..072a9909c 100644 --- a/Source/WebKit/chromium/src/WebPageSerializerImpl.cpp +++ b/Source/WebKit/chromium/src/WebPageSerializerImpl.cpp @@ -417,7 +417,6 @@ void WebPageSerializerImpl::buildContentForNode(Node* node, case Node::ATTRIBUTE_NODE: case Node::DOCUMENT_NODE: case Node::DOCUMENT_FRAGMENT_NODE: - case Node::SHADOW_ROOT_NODE: // Should not exist. ASSERT_NOT_REACHED(); break; diff --git a/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp b/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp index 129088ef4..10c3e2e4b 100644 --- a/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp +++ b/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp @@ -60,6 +60,7 @@ #include "FrameLoadRequest.h" #include "FrameView.h" #include "GraphicsContext.h" +#include "HitTestResult.h" #include "HostWindow.h" #include "HTMLFormElement.h" #include "HTMLNames.h" @@ -433,6 +434,26 @@ void WebPluginContainerImpl::zoomLevelChanged(double zoomLevel) WebViewImpl* view = WebViewImpl::fromPage(m_element->document()->frame()->page()); view->fullFramePluginZoomLevelChanged(zoomLevel); } + +bool WebPluginContainerImpl::isRectTopmost(const WebRect& rect) +{ + Page* page = m_element->document()->page(); + if (!page) + return false; + + // hitTestResultAtPoint() takes a padding rectangle. + // FIXME: We'll be off by 1 when the width or height is even. + IntRect windowRect = convertToContainingWindow(static_cast<IntRect>(rect)); + LayoutPoint center = windowRect.center(); + // Make the rect we're checking (the point surrounded by padding rects) contained inside the requested rect. (Note that -1/2 is 0.) + LayoutSize padding((windowRect.width() - 1) / 2, (windowRect.height() - 1) / 2); + HitTestResult result = + page->mainFrame()->eventHandler()->hitTestResultAtPoint(center, false, false, DontHitTestScrollbars, HitTestRequest::ReadOnly | HitTestRequest::Active, padding); + const HitTestResult::NodeSet& nodes = result.rectBasedTestResult(); + if (nodes.size() != 1) + return false; + return (nodes.first().get() == m_element); +} void WebPluginContainerImpl::didReceiveResponse(const ResourceResponse& response) { @@ -519,17 +540,6 @@ bool WebPluginContainerImpl::paintCustomOverhangArea(GraphicsContext* context, c return true; } -#if ENABLE(GESTURE_EVENTS) -bool WebPluginContainerImpl::handleGestureEvent(const WebCore::PlatformGestureEvent& gestureEvent) -{ - if (m_scrollbarGroup) { - m_scrollbarGroup->handleGestureEvent(gestureEvent); - return true; - } - return false; -} -#endif - // Private methods ------------------------------------------------------------- WebPluginContainerImpl::WebPluginContainerImpl(WebCore::HTMLPlugInElement* element, WebPlugin* webPlugin) diff --git a/Source/WebKit/chromium/src/WebPluginContainerImpl.h b/Source/WebKit/chromium/src/WebPluginContainerImpl.h index 8d6794d6f..898130084 100644 --- a/Source/WebKit/chromium/src/WebPluginContainerImpl.h +++ b/Source/WebKit/chromium/src/WebPluginContainerImpl.h @@ -104,6 +104,7 @@ public: virtual WebString executeScriptURL(const WebURL&, bool popupsAllowed); virtual void loadFrameRequest(const WebURLRequest&, const WebString& target, bool notifyNeeded, void* notifyData); virtual void zoomLevelChanged(double zoomLevel); + virtual bool isRectTopmost(const WebRect&); // This cannot be null. WebPlugin* plugin() { return m_webPlugin; } @@ -150,10 +151,6 @@ public: bool paintCustomOverhangArea(WebCore::GraphicsContext*, const WebCore::IntRect&, const WebCore::IntRect&, const WebCore::IntRect&); -#if ENABLE(GESTURE_EVENTS) - bool handleGestureEvent(const WebCore::PlatformGestureEvent&); -#endif - private: WebPluginContainerImpl(WebCore::HTMLPlugInElement* element, WebPlugin* webPlugin); ~WebPluginContainerImpl(); diff --git a/Source/WebKit/chromium/src/WebRuntimeFeatures.cpp b/Source/WebKit/chromium/src/WebRuntimeFeatures.cpp index 38963b521..f1960eb31 100644 --- a/Source/WebKit/chromium/src/WebRuntimeFeatures.cpp +++ b/Source/WebKit/chromium/src/WebRuntimeFeatures.cpp @@ -450,5 +450,23 @@ bool WebRuntimeFeatures::isShadowDOMEnabled() #endif } +void WebRuntimeFeatures::enableStyleScoped(bool enable) +{ +#if ENABLE(STYLE_SCOPED) + RuntimeEnabledFeatures::setStyleScopedEnabled(enable); +#else + UNUSED_PARAM(enable); +#endif +} + +bool WebRuntimeFeatures::isStyleScopedEnabled() +{ +#if ENABLE(STYLE_SCOPED) + return RuntimeEnabledFeatures::styleScopedEnabled(); +#else + return false; +#endif +} + } // namespace WebKit diff --git a/Source/WebKit/chromium/src/WebScopedUserGesture.cpp b/Source/WebKit/chromium/src/WebScopedUserGesture.cpp new file mode 100644 index 000000000..68426fcae --- /dev/null +++ b/Source/WebKit/chromium/src/WebScopedUserGesture.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2011 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebScopedUserGesture.h" + +#include "UserGestureIndicator.h" + +namespace WebKit { + +void WebScopedUserGesture::initialize() +{ + m_indicator.reset(new WebCore::UserGestureIndicator(WebCore::DefinitelyProcessingUserGesture)); +} + +void WebScopedUserGesture::reset() +{ + m_indicator.reset(0); +} + +} // namespace WebKit diff --git a/Source/WebKit/chromium/src/WebSettingsImpl.cpp b/Source/WebKit/chromium/src/WebSettingsImpl.cpp index 11e9c337b..485a5b051 100644 --- a/Source/WebKit/chromium/src/WebSettingsImpl.cpp +++ b/Source/WebKit/chromium/src/WebSettingsImpl.cpp @@ -288,6 +288,11 @@ void WebSettingsImpl::setExperimentalWebGLEnabled(bool enabled) m_settings->setWebGLEnabled(enabled); } +void WebSettingsImpl::setExperimentalCSSRegionsEnabled(bool enabled) +{ + m_settings->setCSSRegionsEnabled(enabled); +} + void WebSettingsImpl::setOpenGLMultisamplingEnabled(bool enabled) { m_settings->setOpenGLMultisamplingEnabled(enabled); @@ -326,6 +331,7 @@ void WebSettingsImpl::setEditingBehavior(EditingBehavior behavior) void WebSettingsImpl::setAcceleratedCompositingEnabled(bool enabled) { m_settings->setAcceleratedCompositingEnabled(enabled); + m_settings->setScrollingCoordinatorEnabled(enabled); } void WebSettingsImpl::setForceCompositingMode(bool enabled) @@ -457,6 +463,16 @@ void WebSettingsImpl::setAllowRunningOfInsecureContent(bool enabled) m_settings->setAllowRunningOfInsecureContent(enabled); } +void WebSettingsImpl::setPasswordEchoEnabled(bool flag) +{ + m_settings->setPasswordEchoEnabled(flag); +} + +void WebSettingsImpl::setPasswordEchoDurationInSeconds(double durationInSeconds) +{ + m_settings->setPasswordEchoDurationInSeconds(durationInSeconds); +} + void WebSettingsImpl::setShouldPrintBackgrounds(bool enabled) { m_settings->setShouldPrintBackgrounds(enabled); @@ -527,4 +543,9 @@ void WebSettingsImpl::setPartialSwapEnabled(bool enabled) m_settings->setPartialSwapEnabled(enabled); } +void WebSettingsImpl::setThreadedAnimationEnabled(bool enabled) +{ + m_settings->setThreadedAnimationEnabled(enabled); +} + } // namespace WebKit diff --git a/Source/WebKit/chromium/src/WebSettingsImpl.h b/Source/WebKit/chromium/src/WebSettingsImpl.h index 45e62db6f..51d9323a4 100644 --- a/Source/WebKit/chromium/src/WebSettingsImpl.h +++ b/Source/WebKit/chromium/src/WebSettingsImpl.h @@ -88,6 +88,7 @@ public: virtual void setOfflineWebApplicationCacheEnabled(bool); virtual void setWebAudioEnabled(bool); virtual void setExperimentalWebGLEnabled(bool); + virtual void setExperimentalCSSRegionsEnabled(bool); virtual void setOpenGLMultisamplingEnabled(bool); virtual void setPrivilegedWebGLExtensionsEnabled(bool); virtual void setWebGLErrorsToConsoleEnabled(bool); @@ -124,6 +125,8 @@ public: virtual void setFullScreenEnabled(bool); virtual void setAllowDisplayOfInsecureContent(bool); virtual void setAllowRunningOfInsecureContent(bool); + virtual void setPasswordEchoEnabled(bool); + virtual void setPasswordEchoDurationInSeconds(double); virtual void setShouldPrintBackgrounds(bool); virtual void setEnableScrollAnimator(bool); virtual void setHixie76WebSocketProtocolEnabled(bool); @@ -134,6 +137,7 @@ public: virtual void setAcceleratedPaintingEnabled(bool); virtual void setPerTilePaintingEnabled(bool); virtual void setPartialSwapEnabled(bool); + virtual void setThreadedAnimationEnabled(bool); private: WebCore::Settings* m_settings; diff --git a/Source/WebKit/chromium/src/WebSharedWorkerImpl.cpp b/Source/WebKit/chromium/src/WebSharedWorkerImpl.cpp index 7a4bddb22..3fa19d25d 100644 --- a/Source/WebKit/chromium/src/WebSharedWorkerImpl.cpp +++ b/Source/WebKit/chromium/src/WebSharedWorkerImpl.cpp @@ -443,6 +443,7 @@ static void dispatchOnInspectorBackendTask(ScriptExecutionContext* context, cons void WebSharedWorkerImpl::dispatchDevToolsMessage(const WebString& message) { workerThread()->runLoop().postTaskForMode(createCallbackTask(dispatchOnInspectorBackendTask, String(message)), WorkerDebuggerAgent::debuggerTaskMode); + WorkerDebuggerAgent::interruptAndDispatchInspectorCommands(workerThread()); } WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client) diff --git a/Source/WebKit/chromium/src/WebURLResponse.cpp b/Source/WebKit/chromium/src/WebURLResponse.cpp index 2eacda580..ec212e517 100644 --- a/Source/WebKit/chromium/src/WebURLResponse.cpp +++ b/Source/WebKit/chromium/src/WebURLResponse.cpp @@ -47,6 +47,27 @@ using namespace WebCore; namespace WebKit { +namespace { + +class ExtraDataContainer : public ResourceResponse::ExtraData { +public: + static PassRefPtr<ExtraDataContainer> create(WebURLResponse::ExtraData* extraData) { return adoptRef(new ExtraDataContainer(extraData)); } + + virtual ~ExtraDataContainer() { } + + WebURLResponse::ExtraData* extraData() const { return m_extraData.get(); } + +private: + explicit ExtraDataContainer(WebURLResponse::ExtraData* extraData) + : m_extraData(adoptPtr(extraData)) + { + } + + OwnPtr<WebURLResponse::ExtraData> m_extraData; +}; + +} // namespace + // The standard implementation of WebURLResponsePrivate, which maintains // ownership of a ResourceResponse instance. class WebURLResponsePrivateImpl : public WebURLResponsePrivate { @@ -399,6 +420,19 @@ void WebURLResponse::setRemotePort(unsigned short remotePort) m_private->m_resourceResponse->setRemotePort(remotePort); } +WebURLResponse::ExtraData* WebURLResponse::extraData() const +{ + RefPtr<ResourceResponse::ExtraData> data = m_private->m_resourceResponse->extraData(); + if (!data) + return 0; + return static_cast<ExtraDataContainer*>(data.get())->extraData(); +} + +void WebURLResponse::setExtraData(WebURLResponse::ExtraData* extraData) +{ + m_private->m_resourceResponse->setExtraData(ExtraDataContainer::create(extraData)); +} + void WebURLResponse::assign(WebURLResponsePrivate* p) { // Subclasses may call this directly so a self-assignment check is needed diff --git a/Source/WebKit/chromium/src/WebViewImpl.cpp b/Source/WebKit/chromium/src/WebViewImpl.cpp index a05e98920..55a2052a4 100644 --- a/Source/WebKit/chromium/src/WebViewImpl.cpp +++ b/Source/WebKit/chromium/src/WebViewImpl.cpp @@ -99,7 +99,6 @@ #include "RenderWidget.h" #include "ResourceHandle.h" #include "SchemeRegistry.h" -#include "ScrollAnimator.h" #include "SecurityOrigin.h" #include "SecurityPolicy.h" #include "Settings.h" @@ -171,7 +170,7 @@ using namespace std; namespace { -GraphicsContext3D::Attributes getCompositorContextAttributes() +WebKit::WebGraphicsContext3D::Attributes getCompositorContextAttributes(bool threaded) { // Explicitly disable antialiasing for the compositor. As of the time of // this writing, the only platform that supported antialiasing for the @@ -183,12 +182,21 @@ GraphicsContext3D::Attributes getCompositorContextAttributes() // be optimized to resolve directly into the IOSurface shared between the // GPU and browser processes. For these reasons and to avoid platform // disparities we explicitly disable antialiasing. - GraphicsContext3D::Attributes attributes; + WebKit::WebGraphicsContext3D::Attributes attributes; attributes.antialias = false; attributes.shareResources = true; + attributes.forUseOnAnotherThread = threaded; return attributes; } +// The following constants control parameters for automated scaling of webpages +// (such as due to a double tap gesture or find in page etc.). These are +// experimentally determined. +static const int touchPointPadding = 32; +static const float minScaleDifference = 0.01; +static const float doubleTapZoomContentDefaultMargin = 5; +static const float doubleTapZoomContentMinimumMargin = 2; + } // anonymous namespace namespace WebKit { @@ -390,21 +398,21 @@ WebViewImpl::WebViewImpl(WebViewClient* client) pageClients.editorClient = &m_editorClientImpl; pageClients.dragClient = &m_dragClientImpl; pageClients.inspectorClient = &m_inspectorClientImpl; -#if ENABLE(INPUT_SPEECH) - pageClients.speechInputClient = m_speechInputClient.get(); -#endif - pageClients.deviceOrientationClient = m_deviceOrientationClientProxy.get(); pageClients.geolocationClient = m_geolocationClientProxy.get(); -#if ENABLE(NOTIFICATIONS) - pageClients.notificationClient = notificationPresenterImpl(); -#endif pageClients.backForwardClient = BackForwardListChromium::create(this); -#if ENABLE(MEDIA_STREAM) - pageClients.userMediaClient = &m_userMediaClientImpl; -#endif m_page = adoptPtr(new Page(pageClients)); +#if ENABLE(MEDIA_STREAM) + provideUserMediaTo(m_page.get(), &m_userMediaClientImpl); +#endif +#if ENABLE(INPUT_SPEECH) + provideSpeechInputTo(m_page.get(), m_speechInputClient.get()); +#endif +#if ENABLE(NOTIFICATIONS) + provideNotification(m_page.get(), notificationPresenterImpl()); +#endif + provideDeviceOrientationTo(m_page.get(), m_deviceOrientationClientProxy.get()); m_geolocationClientProxy->setController(m_page->geolocationController()); m_page->setGroupName(pageGroupName); @@ -614,14 +622,13 @@ bool WebViewImpl::mouseWheel(const WebMouseWheelEvent& event) bool WebViewImpl::gestureEvent(const WebGestureEvent& event) { PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(), event); - bool handled = mainFrameImpl()->frame()->eventHandler()->handleGestureEvent(platformEvent); - - Frame* frame = mainFrameImpl()->frame(); - WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame); - if (pluginContainer) - handled |= pluginContainer->handleGestureEvent(platformEvent); + return mainFrameImpl()->frame()->eventHandler()->handleGestureEvent(platformEvent); +} - return handled; +void WebViewImpl::startPageScaleAnimation(const IntPoint& scroll, bool useAnchor, float newScale, double durationSec) +{ + if (m_layerTreeHost) + m_layerTreeHost->startPageScaleAnimation(IntSize(scroll.x(), scroll.y()), useAnchor, newScale, durationSec); } #endif @@ -797,15 +804,159 @@ bool WebViewImpl::touchEvent(const WebTouchEvent& event) } #endif +#if ENABLE(GESTURE_EVENTS) +WebRect WebViewImpl::computeBlockBounds(const WebRect& rect, AutoZoomType zoomType) +{ + if (!mainFrameImpl()) + return WebRect(); + + // Use the rect-based hit test to find the node. + IntPoint point = mainFrameImpl()->frameView()->windowToContents(IntPoint(rect.x, rect.y)); + HitTestResult result = mainFrameImpl()->frame()->eventHandler()->hitTestResultAtPoint(point, + false, zoomType == FindInPage, DontHitTestScrollbars, HitTestRequest::Active | HitTestRequest::ReadOnly, + IntSize(rect.width, rect.height)); + + Node* node = result.innerNonSharedNode(); + if (!node) + return WebRect(); + + // Find the block type node based on the hit node. + while (node && (!node->renderer() || node->renderer()->isInline())) + node = node->parentNode(); + + // Return the bounding box in the window coordinate system. + if (node) { + IntRect rect = node->Node::getRect(); + Frame* frame = node->document()->frame(); + return frame->view()->contentsToWindow(rect); + } + return WebRect(); +} + +WebRect WebViewImpl::widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin) +{ + WebSize maxSize; + if (mainFrame()) + maxSize = mainFrame()->contentsSize(); + IntSize scrollOffset; + if (mainFrame()) + scrollOffset = mainFrame()->scrollOffset(); + int leftMargin = targetMargin; + int rightMargin = targetMargin; + + const int absoluteSourceX = source.x + scrollOffset.width(); + if (leftMargin > absoluteSourceX) { + leftMargin = absoluteSourceX; + rightMargin = max(leftMargin, minimumMargin); + } + + const int maximumRightMargin = maxSize.width - (source.width + absoluteSourceX); + if (rightMargin > maximumRightMargin) { + rightMargin = maximumRightMargin; + leftMargin = min(leftMargin, max(rightMargin, minimumMargin)); + } + + const int newWidth = source.width + leftMargin + rightMargin; + const int newX = source.x - leftMargin; + + ASSERT(newWidth >= 0); + ASSERT(scrollOffset.width() + newX + newWidth <= maxSize.width); + + return WebRect(newX, source.y, newWidth, source.height); +} + +void WebViewImpl::computeScaleAndScrollForHitRect(const WebRect& hitRect, AutoZoomType zoomType, float& scale, WebPoint& scroll) +{ + scale = pageScaleFactor(); + scroll.x = scroll.y = 0; + WebRect targetRect = hitRect; + if (targetRect.isEmpty()) + targetRect.width = targetRect.height = touchPointPadding; + + WebRect rect = computeBlockBounds(targetRect, zoomType); + + const float overviewScale = m_minimumPageScaleFactor; + bool scaleUnchanged = true; + if (!rect.isEmpty()) { + // Pages should be as legible as on desktop when at dpi scale, so no + // need to zoom in further when automatically determining zoom level + // (after double tap, find in page, etc), though the user should still + // be allowed to manually pinch zoom in further if they desire. + const float maxScale = deviceScaleFactor(); + + const float defaultMargin = doubleTapZoomContentDefaultMargin * deviceScaleFactor(); + const float minimumMargin = doubleTapZoomContentMinimumMargin * deviceScaleFactor(); + // We want the margins to have the same physical size, which means we + // need to express them in post-scale size. To do that we'd need to know + // the scale we're scaling to, but that depends on the margins. Instead + // we express them as a fraction of the target rectangle: this will be + // correct if we end up fully zooming to it, and won't matter if we + // don't. + rect = widenRectWithinPageBounds(rect, + static_cast<int>(defaultMargin * rect.width / m_size.width), + static_cast<int>(minimumMargin * rect.width / m_size.width)); + + // Fit block to screen, respecting limits. + scale *= static_cast<float>(m_size.width) / rect.width; + scale = min(scale, maxScale); + scale = clampPageScaleFactorToLimits(scale); + + scaleUnchanged = fabs(pageScaleFactor() - scale) < minScaleDifference; + } + + if (zoomType == DoubleTap) { + if (rect.isEmpty() || scaleUnchanged) { + // Zoom out to overview mode. + if (overviewScale) + scale = overviewScale; + return; + } + } else if (rect.isEmpty()) { + // Keep current scale (no need to scroll as x,y will normally already + // be visible). FIXME: Revisit this if it isn't always true. + return; + } + + // FIXME: If this is being called for auto zoom during find in page, + // then if the user manually zooms in it'd be nice to preserve the relative + // increase in zoom they caused (if they zoom out then it's ok to zoom + // them back in again). This isn't compatible with our current double-tap + // zoom strategy (fitting the containing block to the screen) though. + + float screenHeight = m_size.height / scale * pageScaleFactor(); + float screenWidth = m_size.width / scale * pageScaleFactor(); + + // Scroll to vertically align the block. + if (rect.height < screenHeight) { + // Vertically center short blocks. + rect.y -= 0.5 * (screenHeight - rect.height); + } else { + // Ensure position we're zooming to (+ padding) isn't off the bottom of + // the screen. + rect.y = max<float>(rect.y, hitRect.y + touchPointPadding - screenHeight); + } // Otherwise top align the block. + + // Do the same thing for horizontal alignment. + if (rect.width < screenWidth) + rect.x -= 0.5 * (screenWidth - rect.width); + else + rect.x = max<float>(rect.x, hitRect.x + touchPointPadding - screenWidth); + + scroll.x = rect.x; + scroll.y = rect.y; +} +#endif + void WebViewImpl::numberOfWheelEventHandlersChanged(unsigned numberOfWheelHandlers) { - m_haveWheelEventHandlers = numberOfWheelHandlers > 0; if (m_client) m_client->numberOfWheelEventHandlersChanged(numberOfWheelHandlers); -#if USE(ACCELERATED_COMPOSITING) - if (m_layerTreeHost) - m_layerTreeHost->setHaveWheelEventHandlers(m_haveWheelEventHandlers); -#endif +} + +void WebViewImpl::numberOfTouchEventHandlersChanged(unsigned numberOfTouchHandlers) +{ + if (m_client) + m_client->numberOfTouchEventHandlersChanged(numberOfTouchHandlers); } #if !OS(DARWIN) @@ -1257,6 +1408,14 @@ void WebViewImpl::composite(bool) #endif } +void WebViewImpl::setNeedsRedraw() +{ +#if USE(ACCELERATED_COMPOSITING) + if (m_layerTreeHost && isAcceleratedCompositingActive()) + m_layerTreeHost->setNeedsRedraw(); +#endif +} + void WebViewImpl::loseCompositorContext(int numTimes) { #if USE(ACCELERATED_COMPOSITING) @@ -2140,12 +2299,12 @@ bool WebViewImpl::computePageScaleFactorLimits() m_maximumPageScaleFactor = max(m_minimumPageScaleFactor, m_maximumPageScaleFactor); } ASSERT(m_minimumPageScaleFactor <= m_maximumPageScaleFactor); + + float clampedScale = clampPageScaleFactorToLimits(pageScaleFactor()); #if USE(ACCELERATED_COMPOSITING) if (m_layerTreeHost) - m_layerTreeHost->setPageScaleFactorLimits(m_minimumPageScaleFactor, m_maximumPageScaleFactor); + m_layerTreeHost->setPageScaleFactorAndLimits(clampedScale, m_minimumPageScaleFactor, m_maximumPageScaleFactor); #endif - - float clampedScale = clampPageScaleFactorToLimits(pageScaleFactor()); if (clampedScale != pageScaleFactor()) { setPageScaleFactorPreservingScrollOffset(clampedScale); return true; @@ -3005,6 +3164,7 @@ void WebViewImpl::setIsAcceleratedCompositingActive(bool active) ccSettings.perTilePainting = page()->settings()->perTileDrawingEnabled(); ccSettings.partialSwapEnabled = page()->settings()->partialSwapEnabled(); + ccSettings.threadedAnimationEnabled = page()->settings()->threadedAnimationEnabled(); m_nonCompositedContentHost = NonCompositedContentHost::create(WebViewImplContentPainter::create(this)); m_nonCompositedContentHost->setShowDebugBorders(page()->settings()->showDebugBorders()); @@ -3014,8 +3174,7 @@ void WebViewImpl::setIsAcceleratedCompositingActive(bool active) m_layerTreeHost = CCLayerTreeHost::create(this, ccSettings); if (m_layerTreeHost) { - m_layerTreeHost->setHaveWheelEventHandlers(m_haveWheelEventHandlers); - m_layerTreeHost->setPageScaleFactorLimits(m_minimumPageScaleFactor, m_maximumPageScaleFactor); + m_layerTreeHost->setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor); updateLayerTreeViewport(); m_client->didActivateCompositor(m_layerTreeHost->compositorIdentifier()); m_isAcceleratedCompositingActive = true; @@ -3036,15 +3195,25 @@ void WebViewImpl::setIsAcceleratedCompositingActive(bool active) #endif +PassRefPtr<GraphicsContext3D> WebViewImpl::createCompositorGraphicsContext3D() +{ + WebKit::WebGraphicsContext3D::Attributes attributes = getCompositorContextAttributes(CCProxy::hasImplThread()); + OwnPtr<WebGraphicsContext3D> webContext = adoptPtr(client()->createGraphicsContext3D(attributes, true /* renderDirectlyToHostWindow */)); + if (!webContext) + return 0; + + return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), GraphicsContext3D::RenderDirectlyToHostWindow); +} + PassRefPtr<GraphicsContext3D> WebViewImpl::createLayerTreeHostContext3D() { - RefPtr<GraphicsContext3D> context = m_temporaryOnscreenGraphicsContext3D.release(); - if (!context) { - if (CCProxy::hasImplThread()) - context = GraphicsContext3DPrivate::createGraphicsContextForAnotherThread(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow); - else - context = GraphicsContext3D::create(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow); - } + RefPtr<GraphicsContext3D> context; + + // If we've already created an onscreen context for this view, return that. + if (m_temporaryOnscreenGraphicsContext3D) + context = m_temporaryOnscreenGraphicsContext3D.release(); + else // Otherwise make a new one. + context = createCompositorGraphicsContext3D(); return context; } @@ -3125,7 +3294,7 @@ void WebViewImpl::updateLayerTreeViewport() } m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll, pageScaleFactor(), layerAdjustX); m_layerTreeHost->setViewportSize(visibleRect.size()); - m_layerTreeHost->setPageScale(pageScaleFactor()); + m_layerTreeHost->setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor); } WebGraphicsContext3D* WebViewImpl::graphicsContext3D() @@ -3137,17 +3306,16 @@ WebGraphicsContext3D* WebViewImpl::graphicsContext3D() if (webContext && !webContext->isContextLost()) return webContext; } - if (m_temporaryOnscreenGraphicsContext3D) { - WebGraphicsContext3D* webContext = GraphicsContext3DPrivate::extractWebGraphicsContext3D(m_temporaryOnscreenGraphicsContext3D.get()); - if (webContext && !webContext->isContextLost()) - return webContext; - } - if (CCProxy::hasImplThread()) - m_temporaryOnscreenGraphicsContext3D = GraphicsContext3DPrivate::createGraphicsContextForAnotherThread(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow); - else - m_temporaryOnscreenGraphicsContext3D = GraphicsContext3D::create(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow); - - return GraphicsContext3DPrivate::extractWebGraphicsContext3D(m_temporaryOnscreenGraphicsContext3D.get()); + // If we get here it means that some system needs access to the context the compositor will use but the compositor itself + // hasn't requested a context or it was unable to successfully instantiate a context. + // We need to return the context that the compositor will later use so we allocate a new context (if needed) and stash it + // until the compositor requests and takes ownership of the context via createLayerTreeHost3D(). + if (!m_temporaryOnscreenGraphicsContext3D) + m_temporaryOnscreenGraphicsContext3D = createCompositorGraphicsContext3D(); + + WebGraphicsContext3D* webContext = GraphicsContext3DPrivate::extractWebGraphicsContext3D(m_temporaryOnscreenGraphicsContext3D.get()); + if (webContext && !webContext->isContextLost()) + return webContext; } #endif return 0; diff --git a/Source/WebKit/chromium/src/WebViewImpl.h b/Source/WebKit/chromium/src/WebViewImpl.h index 800d18254..bc7a53d04 100644 --- a/Source/WebKit/chromium/src/WebViewImpl.h +++ b/Source/WebKit/chromium/src/WebViewImpl.h @@ -45,6 +45,7 @@ #include "GraphicsContext3D.h" #include "GraphicsLayer.h" #include "InspectorClientImpl.h" +#include "IntPoint.h" #include "IntRect.h" #include "NotificationPresenterImpl.h" #include "PageOverlayList.h" @@ -95,6 +96,11 @@ class WebTouchEvent; class WebViewImpl : public WebView, public WebCore::CCLayerTreeHostClient, public RefCounted<WebViewImpl> { public: + enum AutoZoomType { + DoubleTap, + FindInPage, + }; + // WebWidget methods: virtual void close(); virtual WebSize size() { return m_size; } @@ -110,6 +116,7 @@ public: virtual void paint(WebCanvas*, const WebRect&); virtual void themeChanged(); virtual void composite(bool finish); + virtual void setNeedsRedraw(); virtual bool handleInputEvent(const WebInputEvent&); virtual void mouseCaptureLost(); virtual void setFocus(bool enable); @@ -314,11 +321,13 @@ public: void mouseDoubleClick(const WebMouseEvent&); bool mouseWheel(const WebMouseWheelEvent&); bool gestureEvent(const WebGestureEvent&); + void startPageScaleAnimation(const WebCore::IntPoint& targetPosition, bool useAnchor, float newScale, double durationSec); bool keyEvent(const WebKeyboardEvent&); bool charEvent(const WebKeyboardEvent&); bool touchEvent(const WebTouchEvent&); void numberOfWheelEventHandlersChanged(unsigned); + void numberOfTouchEventHandlersChanged(unsigned); // Handles context menu events orignated via the the keyboard. These // include the VK_APPS virtual key and the Shift+F10 combine. Code is @@ -437,9 +446,12 @@ public: // Returns the onscreen 3D context used by the compositor. This is // used by the renderer's code to set up resource sharing between // the compositor's context and subordinate contexts for APIs like - // WebGL. Returns 0 if compositing support is not compiled in. + // WebGL. Returns 0 if compositing support is not compiled in or + // we could not successfully instantiate a context. virtual WebGraphicsContext3D* graphicsContext3D(); + PassRefPtr<WebCore::GraphicsContext3D> createCompositorGraphicsContext3D(); + virtual void setVisibilityState(WebPageVisibilityState, bool); WebCore::PopupContainer* selectPopup() const { return m_selectPopup.get(); } @@ -455,6 +467,10 @@ public: // a plugin can update its own zoom, say because of its own UI. void fullFramePluginZoomLevelChanged(double zoomLevel); +#if ENABLE(GESTURE_EVENTS) + void computeScaleAndScrollForHitRect(const WebRect& hitRect, AutoZoomType, float& scale, WebPoint& scroll); +#endif + void loseCompositorContext(int numTimes); void enterFullScreenForElement(WebCore::Element*); @@ -525,6 +541,15 @@ private: void updateLayerTreeViewport(); #endif +#if ENABLE(GESTURE_EVENTS) + // Returns the bounding box of the block type node touched by the WebRect. + WebRect computeBlockBounds(const WebRect&, AutoZoomType); + + // Helper function: Widens the width of |source| by the specified margins + // while keeping it smaller than page width. + WebRect widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin); +#endif + #if ENABLE(POINTER_LOCK) void pointerLockMouseEvent(const WebInputEvent&); #endif @@ -670,7 +695,6 @@ private: // If true, the graphics context is being restored. bool m_recreatingGraphicsContext; #endif - bool m_haveWheelEventHandlers; static const WebInputEvent* m_currentInputEvent; #if ENABLE(INPUT_SPEECH) diff --git a/Source/WebKit/chromium/src/WebWorkerClientImpl.cpp b/Source/WebKit/chromium/src/WebWorkerClientImpl.cpp index 796ab166d..1db2d1dd9 100644 --- a/Source/WebKit/chromium/src/WebWorkerClientImpl.cpp +++ b/Source/WebKit/chromium/src/WebWorkerClientImpl.cpp @@ -39,6 +39,7 @@ #include "ErrorEvent.h" #include "Frame.h" #include "FrameLoaderClient.h" +#include "InspectorInstrumentation.h" #include "MessageEvent.h" #include "MessagePort.h" #include "MessagePortChannel.h" @@ -90,6 +91,7 @@ void WebWorkerClientImpl::startWorkerContext(const KURL& scriptURL, const String m_scriptExecutionContext->contentSecurityPolicy()->headerType()); m_proxy->workerThreadCreated(thread); thread->start(); + InspectorInstrumentation::didStartWorkerContext(m_scriptExecutionContext.get(), m_proxy, scriptURL); } void WebWorkerClientImpl::terminateWorkerContext() diff --git a/Source/WebKit/chromium/src/js/Tests.js b/Source/WebKit/chromium/src/js/Tests.js index a41eefdd0..16a1ba257 100644 --- a/Source/WebKit/chromium/src/js/Tests.js +++ b/Source/WebKit/chromium/src/js/Tests.js @@ -308,7 +308,6 @@ TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch = function() this.showPanel("scripts"); - function switchToElementsTab() { test.showPanel("elements"); setTimeout(switchToScriptsTab, 0); @@ -320,19 +319,17 @@ TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch = function() } function checkScriptsPanel() { - test.assertTrue(!!WebInspector.panels.scripts.visibleView, "No visible script view."); test.assertTrue(test._scriptsAreParsed(["debugger_test_page.html"]), "Some scripts are missing."); checkNoDuplicates(); test.releaseControl(); } function checkNoDuplicates() { - var scriptSelect = document.getElementById("scripts-files"); - var options = scriptSelect.options; - for (var i = 0; i < options.length; i++) { - var scriptName = options[i].text; - for (var j = i + 1; j < options.length; j++) - test.assertTrue(scriptName !== options[j].text, "Found script duplicates: " + test.optionsToString_(options)); + var uiSourceCodes = test.nonAnonymousUISourceCodes_(); + for (var i = 0; i < uiSourceCodes.length; i++) { + var scriptName = uiSourceCodes[i].fileName; + for (var j = i + 1; j < uiSourceCodes.length; j++) + test.assertTrue(scriptName !== uiSourceCodes[j].fileName, "Found script duplicates: " + test.uiSourceCodesToString_(uiSourceCodes)); } } @@ -584,70 +581,32 @@ TestSuite.prototype.waitForTestResultsInConsole = function() /** - * Serializes options collection to string. - * @param {HTMLOptionsCollection} options + * Serializes array of uiSourceCodes to string. + * @param {Array.<WebInspectorUISourceCode>} uiSourceCodes * @return {string} */ -TestSuite.prototype.optionsToString_ = function(options) +TestSuite.prototype.uiSourceCodesToString_ = function(uiSourceCodes) { var names = []; - for (var i = 0; i < options.length; i++) - names.push('"' + options[i].text + '"'); + for (var i = 0; i < uiSourceCodes.length; i++) + names.push('"' + uiSourceCodes[i].fileName + '"'); return names.join(","); }; /** - * Ensures that main HTML resource is selected in Scripts panel and that its - * source frame is setup. Invokes the callback when the condition is satisfied. - * @param {HTMLOptionsCollection} options - * @param {function(WebInspector.SourceView,string)} callback + * Returns all loaded non anonymous uiSourceCodes. + * @return {Array.<WebInspectorUISourceCode>} */ -TestSuite.prototype.showMainPageScriptSource_ = function(scriptName, callback) +TestSuite.prototype.nonAnonymousUISourceCodes_ = function() { - var test = this; - - var scriptSelect = document.getElementById("scripts-files"); - var options = scriptSelect.options; - - test.assertTrue(options.length, "Scripts list is empty"); - - // Select page's script if it's not current option. - var scriptResource; - if (options[scriptSelect.selectedIndex].text === scriptName) - scriptResource = options[scriptSelect.selectedIndex].representedObject; - else { - var pageScriptIndex = -1; - for (var i = 0; i < options.length; i++) { - if (options[i].text === scriptName) { - pageScriptIndex = i; - break; - } - } - test.assertTrue(-1 !== pageScriptIndex, "Script with url " + scriptName + " not found among " + test.optionsToString_(options)); - scriptResource = options[pageScriptIndex].representedObject; - - // Current panel is "Scripts". - WebInspector.inspectorView.currentPanel()._showScriptOrResource(scriptResource); - test.assertEquals(pageScriptIndex, scriptSelect.selectedIndex, "Unexpected selected option index."); + function filterOutAnonymous(uiSourceCode) + { + return !!uiSourceCode.url; } - test.assertTrue(scriptResource instanceof WebInspector.Resource, - "Unexpected resource class."); - test.assertTrue(!!scriptResource.url, "Resource URL is null."); - test.assertTrue(scriptResource.url.search(scriptName + "$") !== -1, "Main HTML resource should be selected."); - - var scriptsPanel = WebInspector.panels.scripts; - - var view = scriptsPanel.visibleView; - test.assertTrue(view instanceof WebInspector.SourceView); - - if (!view.sourceFrame._loaded) { - test.addSniffer(view, "_sourceFrameSetupFinished", function(event) { - callback(view, scriptResource.url); - }); - } else - callback(view, scriptResource.url); + var uiSourceCodes = WebInspector.panels.scripts._presentationModel.uiSourceCodes(); + return uiSourceCodes.filter(filterOutAnonymous); }; @@ -680,14 +639,12 @@ TestSuite.prototype.evaluateInConsole_ = function(code, callback) */ TestSuite.prototype._scriptsAreParsed = function(expected) { - var scriptSelect = document.getElementById("scripts-files"); - var options = scriptSelect.options; - + var uiSourceCodes = this.nonAnonymousUISourceCodes_(); // Check that at least all the expected scripts are present. var missing = expected.slice(0); - for (var i = 0 ; i < options.length; i++) { - for (var j = 0; j < missing.length; j++) { - if (options[i].text.search(missing[j]) !== -1) { + for (var i = 0; i < uiSourceCodes.length; ++i) { + for (var j = 0; j < missing.length; ++j) { + if (uiSourceCodes[i].fileName.search(missing[j]) !== -1) { missing.splice(j, 1); break; } @@ -744,7 +701,7 @@ TestSuite.prototype._waitUntilScriptsAreParsed = function(expectedScripts, callb if (test._scriptsAreParsed(expectedScripts)) callback(); else - test.addSniffer(WebInspector.panels.scripts, "_uiSourceCodeAdded", waitForAllScripts); + test.addSniffer(WebInspector.panels.scripts, "_addUISourceCode", waitForAllScripts); } waitForAllScripts(); diff --git a/Source/WebKit/chromium/tests/CCActiveAnimationTest.cpp b/Source/WebKit/chromium/tests/CCActiveAnimationTest.cpp index 3e93d95de..e14ef9bc0 100644 --- a/Source/WebKit/chromium/tests/CCActiveAnimationTest.cpp +++ b/Source/WebKit/chromium/tests/CCActiveAnimationTest.cpp @@ -25,24 +25,20 @@ #include "config.h" #include "cc/CCActiveAnimation.h" - -#include "cc/CCAnimationCurve.h" +#include "CCAnimationTestCommon.h" #include <gmock/gmock.h> #include <gtest/gtest.h> #include <wtf/Vector.h> -namespace WebCore { +using namespace WebKitTests; +using namespace WebCore; -class FakeFloatAnimation : public CCFloatAnimationCurve { -public: - virtual double duration() const { return 1; } - virtual float getValue(double now) const { return 0; } -}; +namespace { PassOwnPtr<CCActiveAnimation> createActiveAnimation(int iterations) { - OwnPtr<CCActiveAnimation> toReturn(CCActiveAnimation::create(adoptPtr(new FakeFloatAnimation), 1, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toReturn(CCActiveAnimation::create(adoptPtr(new FakeFloatAnimationCurve), 0, 1, CCActiveAnimation::Opacity)); toReturn->setIterations(iterations); return toReturn.release(); } @@ -164,4 +160,4 @@ TEST(CCActiveAnimationTest, IsFinished) EXPECT_TRUE(anim->isFinished()); } -} // namespace WebCore +} // namespace diff --git a/Source/WebKit/chromium/tests/CCAnimationTestCommon.cpp b/Source/WebKit/chromium/tests/CCAnimationTestCommon.cpp new file mode 100644 index 000000000..c9240e31f --- /dev/null +++ b/Source/WebKit/chromium/tests/CCAnimationTestCommon.cpp @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "CCAnimationTestCommon.h" + +#include "GraphicsLayer.h" +#include "LayerChromium.h" +#include "cc/CCLayerAnimationController.h" + +using namespace WebCore; + +namespace { + +template <class Target> +void addOpacityTransition(Target& target, double duration, float startOpacity, float endOpacity) +{ + WebCore::KeyframeValueList values(AnimatedPropertyOpacity); + if (duration > 0) + values.insert(new FloatAnimationValue(0, startOpacity)); + values.insert(new FloatAnimationValue(duration, endOpacity)); + + RefPtr<Animation> animation = Animation::create(); + animation->setDuration(duration); + + IntSize boxSize; + + target.addAnimation(values, boxSize, animation.get(), 0, 0, 0); +} + +} // namespace + +namespace WebKitTests { + +FakeFloatAnimationCurve::FakeFloatAnimationCurve() +{ +} + +FakeFloatAnimationCurve::~FakeFloatAnimationCurve() +{ +} + +PassOwnPtr<WebCore::CCAnimationCurve> FakeFloatAnimationCurve::clone() const +{ + return adoptPtr(new FakeFloatAnimationCurve); +} + +FakeTransformTransition::FakeTransformTransition(double duration) + : m_duration(duration) +{ +} + +FakeTransformTransition::~FakeTransformTransition() +{ +} + +WebCore::TransformationMatrix FakeTransformTransition::getValue(double time, const WebCore::IntSize& size) const +{ + return WebCore::TransformationMatrix(); +} + +PassOwnPtr<WebCore::CCAnimationCurve> FakeTransformTransition::clone() const +{ + return adoptPtr(new FakeTransformTransition(*this)); +} + + +FakeFloatTransition::FakeFloatTransition(double duration, float from, float to) + : m_duration(duration) + , m_from(from) + , m_to(to) +{ +} + +FakeFloatTransition::~FakeFloatTransition() +{ +} + +float FakeFloatTransition::getValue(double time) const +{ + time /= m_duration; + if (time >= 1) + time = 1; + return (1 - time) * m_from + time * m_to; +} + +FakeLayerAnimationControllerImplClient::FakeLayerAnimationControllerImplClient() + : m_opacity(0) +{ +} + +FakeLayerAnimationControllerImplClient::~FakeLayerAnimationControllerImplClient() +{ +} + +PassOwnPtr<WebCore::CCAnimationCurve> FakeFloatTransition::clone() const +{ + return adoptPtr(new FakeFloatTransition(*this)); +} + +void addOpacityTransitionToController(WebCore::CCLayerAnimationController& controller, double duration, float startOpacity, float endOpacity) +{ + addOpacityTransition(controller, duration, startOpacity, endOpacity); +} + +void addOpacityTransitionToLayer(WebCore::LayerChromium& layer, double duration, float startOpacity, float endOpacity) +{ + addOpacityTransition(layer, duration, startOpacity, endOpacity); +} + +} // namespace WebKitTests diff --git a/Source/WebKit/chromium/tests/CCAnimationTestCommon.h b/Source/WebKit/chromium/tests/CCAnimationTestCommon.h new file mode 100644 index 000000000..d13e74ca1 --- /dev/null +++ b/Source/WebKit/chromium/tests/CCAnimationTestCommon.h @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef CCAnimationTestCommon_h +#define CCAnimationTestCommon_h + +#include "cc/CCAnimationCurve.h" +#include "cc/CCLayerAnimationControllerImpl.h" + +#include <wtf/OwnPtr.h> + +namespace WebCore { +class CCLayerAnimationController; +class LayerChromium; +} + +namespace WebKitTests { + +class FakeFloatAnimationCurve : public WebCore::CCFloatAnimationCurve { +public: + FakeFloatAnimationCurve(); + virtual ~FakeFloatAnimationCurve(); + + virtual double duration() const { return 1; } + virtual float getValue(double now) const { return 0; } + virtual PassOwnPtr<WebCore::CCAnimationCurve> clone() const; +}; + +class FakeTransformTransition : public WebCore::CCTransformAnimationCurve { +public: + FakeTransformTransition(double duration); + virtual ~FakeTransformTransition(); + + virtual double duration() const { return m_duration; } + virtual WebCore::TransformationMatrix getValue(double time, const WebCore::IntSize&) const; + + virtual PassOwnPtr<WebCore::CCAnimationCurve> clone() const; + +private: + double m_duration; +}; + +class FakeFloatTransition : public WebCore::CCFloatAnimationCurve { +public: + FakeFloatTransition(double duration, float from, float to); + virtual ~FakeFloatTransition(); + + virtual double duration() const { return m_duration; } + virtual float getValue(double time) const; + + virtual PassOwnPtr<WebCore::CCAnimationCurve> clone() const; + +private: + double m_duration; + float m_from; + float m_to; +}; + +class FakeLayerAnimationControllerImplClient : public WebCore::CCLayerAnimationControllerImplClient { +public: + FakeLayerAnimationControllerImplClient(); + virtual ~FakeLayerAnimationControllerImplClient(); + + virtual int id() const { return 0; } + virtual float opacity() const { return m_opacity; } + virtual void setOpacity(float opacity) { m_opacity = opacity; } + virtual const WebCore::TransformationMatrix& transform() const { return m_transform; } + virtual void setTransform(const WebCore::TransformationMatrix& transform) { m_transform = transform; } + virtual const WebCore::IntSize& bounds() const { return m_bounds; } + +private: + float m_opacity; + WebCore::TransformationMatrix m_transform; + WebCore::IntSize m_bounds; +}; + +void addOpacityTransitionToController(WebCore::CCLayerAnimationController&, double duration, float startOpacity, float endOpacity); + +void addOpacityTransitionToLayer(WebCore::LayerChromium&, double duration, float startOpacity, float endOpacity); + +} // namespace WebKitTests + +#endif // CCAnimationTesctCommon_h diff --git a/Source/WebKit/chromium/tests/CCKeyframedAnimationCurveTest.cpp b/Source/WebKit/chromium/tests/CCKeyframedAnimationCurveTest.cpp new file mode 100644 index 000000000..b7732aeab --- /dev/null +++ b/Source/WebKit/chromium/tests/CCKeyframedAnimationCurveTest.cpp @@ -0,0 +1,241 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "cc/CCKeyframedAnimationCurve.h" + +#include "Length.h" +#include "TranslateTransformOperation.h" + +#include <gmock/gmock.h> +#include <gtest/gtest.h> +#include <wtf/OwnPtr.h> +#include <wtf/Vector.h> + +using namespace WebCore; + +namespace { + +void expectTranslateX(double translateX, const TransformationMatrix& matrix) +{ + TransformationMatrix::DecomposedType decomposedType; + matrix.decompose(decomposedType); + EXPECT_FLOAT_EQ(translateX, decomposedType.translateX); +} + +// Tests that a float animation with one keyframe works as expected. +TEST(CCKeyframedAnimationCurveTest, OneFloatKeyframe) +{ + Vector<CCFloatKeyframe> keyframes; + keyframes.append(CCFloatKeyframe(0, 2)); + OwnPtr<CCKeyframedFloatAnimationCurve> curve(CCKeyframedFloatAnimationCurve::create(keyframes)); + EXPECT_FLOAT_EQ(2, curve->getValue(-1)); + EXPECT_FLOAT_EQ(2, curve->getValue(0)); + EXPECT_FLOAT_EQ(2, curve->getValue(0.5)); + EXPECT_FLOAT_EQ(2, curve->getValue(1)); + EXPECT_FLOAT_EQ(2, curve->getValue(2)); +} + +// Tests that a float animation with two keyframes works as expected. +TEST(CCKeyframedAnimationCurveTest, TwoFloatKeyframe) +{ + Vector<CCFloatKeyframe> keyframes; + keyframes.append(CCFloatKeyframe(0, 2)); + keyframes.append(CCFloatKeyframe(1, 4)); + OwnPtr<CCKeyframedFloatAnimationCurve> curve(CCKeyframedFloatAnimationCurve::create(keyframes)); + EXPECT_FLOAT_EQ(2, curve->getValue(-1)); + EXPECT_FLOAT_EQ(2, curve->getValue(0)); + EXPECT_FLOAT_EQ(3, curve->getValue(0.5)); + EXPECT_FLOAT_EQ(4, curve->getValue(1)); + EXPECT_FLOAT_EQ(4, curve->getValue(2)); +} + +// Tests that a float animation with three keyframes works as expected. +TEST(CCKeyframedAnimationCurveTest, ThreeFloatKeyframe) +{ + Vector<CCFloatKeyframe> keyframes; + keyframes.append(CCFloatKeyframe(0, 2)); + keyframes.append(CCFloatKeyframe(1, 4)); + keyframes.append(CCFloatKeyframe(2, 8)); + OwnPtr<CCKeyframedFloatAnimationCurve> curve(CCKeyframedFloatAnimationCurve::create(keyframes)); + EXPECT_FLOAT_EQ(2, curve->getValue(-1)); + EXPECT_FLOAT_EQ(2, curve->getValue(0)); + EXPECT_FLOAT_EQ(3, curve->getValue(0.5)); + EXPECT_FLOAT_EQ(4, curve->getValue(1)); + EXPECT_FLOAT_EQ(6, curve->getValue(1.5)); + EXPECT_FLOAT_EQ(8, curve->getValue(2)); + EXPECT_FLOAT_EQ(8, curve->getValue(3)); +} + +// Tests that a float animation with multiple keys at a given time works sanely. +TEST(CCKeyframedAnimationCurveTest, RepeatedFloatKeyTimes) +{ + Vector<CCFloatKeyframe> keyframes; + // A step function. + keyframes.append(CCFloatKeyframe(0, 4)); + keyframes.append(CCFloatKeyframe(1, 4)); + keyframes.append(CCFloatKeyframe(1, 6)); + keyframes.append(CCFloatKeyframe(2, 6)); + OwnPtr<CCKeyframedFloatAnimationCurve> curve(CCKeyframedFloatAnimationCurve::create(keyframes)); + + EXPECT_FLOAT_EQ(4, curve->getValue(-1)); + EXPECT_FLOAT_EQ(4, curve->getValue(0)); + EXPECT_FLOAT_EQ(4, curve->getValue(0.5)); + + // There is a discontinuity at 1. Any value between 4 and 6 is valid. + float value = curve->getValue(1); + EXPECT_TRUE(value >= 4 && value <= 6); + + EXPECT_FLOAT_EQ(6, curve->getValue(1.5)); + EXPECT_FLOAT_EQ(6, curve->getValue(2)); + EXPECT_FLOAT_EQ(6, curve->getValue(3)); +} + + +// Tests that a transform animation with one keyframe works as expected. +TEST(CCKeyframedAnimationCurveTest, OneTransformKeyframe) +{ + Vector<CCTransformKeyframe> keyframes; + TransformOperations operations; + operations.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + keyframes.append(CCTransformKeyframe(0, operations)); + OwnPtr<CCKeyframedTransformAnimationCurve> curve(CCKeyframedTransformAnimationCurve::create(keyframes)); + IntSize layerSize; // ignored + expectTranslateX(2, curve->getValue(-1, layerSize)); + expectTranslateX(2, curve->getValue(0, layerSize)); + expectTranslateX(2, curve->getValue(0.5, layerSize)); + expectTranslateX(2, curve->getValue(1, layerSize)); + expectTranslateX(2, curve->getValue(2, layerSize)); +} + +// Tests that a transform animation with two keyframes works as expected. +TEST(CCKeyframedAnimationCurveTest, TwoTransformKeyframe) +{ + Vector<CCTransformKeyframe> keyframes; + TransformOperations operations1; + operations1.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations2; + operations2.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + keyframes.append(CCTransformKeyframe(0, operations1)); + keyframes.append(CCTransformKeyframe(1, operations2)); + OwnPtr<CCKeyframedTransformAnimationCurve> curve(CCKeyframedTransformAnimationCurve::create(keyframes)); + IntSize layerSize; // ignored + expectTranslateX(2, curve->getValue(-1, layerSize)); + expectTranslateX(2, curve->getValue(0, layerSize)); + expectTranslateX(3, curve->getValue(0.5, layerSize)); + expectTranslateX(4, curve->getValue(1, layerSize)); + expectTranslateX(4, curve->getValue(2, layerSize)); +} + +// Tests that a transform animation with three keyframes works as expected. +TEST(CCKeyframedAnimationCurveTest, ThreeTransformKeyframe) +{ + Vector<CCTransformKeyframe> keyframes; + TransformOperations operations1; + operations1.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations2; + operations2.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations3; + operations3.operations().append(TranslateTransformOperation::create(Length(8, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + keyframes.append(CCTransformKeyframe(0, operations1)); + keyframes.append(CCTransformKeyframe(1, operations2)); + keyframes.append(CCTransformKeyframe(2, operations3)); + OwnPtr<CCKeyframedTransformAnimationCurve> curve(CCKeyframedTransformAnimationCurve::create(keyframes)); + IntSize layerSize; // ignored + expectTranslateX(2, curve->getValue(-1, layerSize)); + expectTranslateX(2, curve->getValue(0, layerSize)); + expectTranslateX(3, curve->getValue(0.5, layerSize)); + expectTranslateX(4, curve->getValue(1, layerSize)); + expectTranslateX(6, curve->getValue(1.5, layerSize)); + expectTranslateX(8, curve->getValue(2, layerSize)); + expectTranslateX(8, curve->getValue(3, layerSize)); +} + +// Tests that a transform animation with multiple keys at a given time works sanely. +TEST(CCKeyframedAnimationCurveTest, RepeatedTransformKeyTimes) +{ + Vector<CCTransformKeyframe> keyframes; + // A step function. + TransformOperations operations1; + operations1.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations2; + operations2.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations3; + operations3.operations().append(TranslateTransformOperation::create(Length(6, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations4; + operations4.operations().append(TranslateTransformOperation::create(Length(6, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + keyframes.append(CCTransformKeyframe(0, operations1)); + keyframes.append(CCTransformKeyframe(1, operations2)); + keyframes.append(CCTransformKeyframe(1, operations3)); + keyframes.append(CCTransformKeyframe(2, operations4)); + OwnPtr<CCKeyframedTransformAnimationCurve> curve(CCKeyframedTransformAnimationCurve::create(keyframes)); + + IntSize layerSize; // ignored + + expectTranslateX(4, curve->getValue(-1, layerSize)); + expectTranslateX(4, curve->getValue(0, layerSize)); + expectTranslateX(4, curve->getValue(0.5, layerSize)); + + // There is a discontinuity at 1. Any value between 4 and 6 is valid. + TransformationMatrix value = curve->getValue(1, layerSize); + TransformationMatrix::DecomposedType decomposedType; + value.decompose(decomposedType); + EXPECT_TRUE(decomposedType.translateX >= 4 && decomposedType.translateX <= 6); + + expectTranslateX(6, curve->getValue(1.5, layerSize)); + expectTranslateX(6, curve->getValue(2, layerSize)); + expectTranslateX(6, curve->getValue(3, layerSize)); +} + +// Tests that invalid lists of keyframes result in nothing being returned from ::create. +TEST(CCKeyframedAnimationCurveTest, InvalidKeyframes) +{ + // It is invalid to pass an empty vector of keyframes to create. + Vector<CCTransformKeyframe> transformKeyframes; + OwnPtr<CCKeyframedTransformAnimationCurve> transformCurve = CCKeyframedTransformAnimationCurve::create(transformKeyframes); + EXPECT_FALSE(transformCurve.get()); + + Vector<CCFloatKeyframe> floatKeyframes; + OwnPtr<CCKeyframedFloatAnimationCurve> floatCurve = CCKeyframedFloatAnimationCurve::create(floatKeyframes); + EXPECT_FALSE(floatCurve.get()); + + // It is invalid to pass a vector of unsorted keyframes to create; + TransformOperations operations1; + operations1.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + TransformOperations operations2; + operations2.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + transformKeyframes.append(CCTransformKeyframe(1, operations1)); + transformKeyframes.append(CCTransformKeyframe(0, operations2)); + transformCurve = CCKeyframedTransformAnimationCurve::create(transformKeyframes); + EXPECT_FALSE(transformCurve.get()); + + floatKeyframes.append(CCFloatKeyframe(1, 2)); + floatKeyframes.append(CCFloatKeyframe(0, 4)); + floatCurve = CCKeyframedFloatAnimationCurve::create(floatKeyframes); + EXPECT_FALSE(floatCurve.get()); +} + + +} // namespace diff --git a/Source/WebKit/chromium/tests/CCLayerAnimationControllerImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerAnimationControllerImplTest.cpp index 3d50d06e6..e1aeccc53 100644 --- a/Source/WebKit/chromium/tests/CCLayerAnimationControllerImplTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerAnimationControllerImplTest.cpp @@ -24,92 +24,39 @@ #include "config.h" +#include "CCAnimationTestCommon.h" #include "cc/CCLayerAnimationControllerImpl.h" - -#include "TransformOperations.h" #include "cc/CCAnimationCurve.h" - +#include "cc/CCAnimationEvents.h" #include <gmock/gmock.h> #include <gtest/gtest.h> #include <wtf/Vector.h> using namespace WebCore; +using namespace WebKitTests; namespace { -class FakeControllerClient : public CCLayerAnimationControllerImplClient { -public: - FakeControllerClient() : m_opacity(0) { } - virtual ~FakeControllerClient() { } - - virtual float opacity() const { return m_opacity; } - virtual void setOpacity(float opacity) { m_opacity = opacity; } - virtual const TransformationMatrix& transform() const { return m_transform; } - virtual void setTransform(const TransformationMatrix& transform) { m_transform = transform; } - virtual void animationControllerImplDidActivate(CCLayerAnimationControllerImpl* controller) - { - m_activeControllers.append(controller); - } - - Vector<CCLayerAnimationControllerImpl*>& activeControllers() { return m_activeControllers; } - -private: - float m_opacity; - TransformationMatrix m_transform; - Vector<CCLayerAnimationControllerImpl*> m_activeControllers; -}; - -class FakeTransformTransition : public CCTransformAnimationCurve { -public: - FakeTransformTransition(double duration) : m_duration(duration) { } - virtual double duration() const { return m_duration; } - virtual TransformOperations getValue(double time) const - { - return TransformOperations(); - } - -private: - double m_duration; -}; - -class FakeFloatTransition : public CCFloatAnimationCurve { -public: - FakeFloatTransition(double duration, float from, float to) - : m_duration(duration) - , m_from(from) - , m_to(to) - { - } - - virtual double duration() const { return m_duration; } - virtual float getValue(double time) const - { - time /= m_duration; - if (time >= 1) - time = 1; - return (1 - time) * m_from + time * m_to; - } - -private: - double m_duration; - float m_from; - float m_to; -}; +PassOwnPtr<CCActiveAnimation> createActiveAnimation(PassOwnPtr<CCAnimationCurve> curve, int id, CCActiveAnimation::TargetProperty property) +{ + return CCActiveAnimation::create(curve, 0, id, property); +} // Tests that transitioning opacity from 0 to 1 works as expected. TEST(CCLayerAnimationControllerImplTest, TrivialTransition) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); controller->add(toAdd.release()); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(1); + controller->animate(1, *events); EXPECT_EQ(1, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -117,20 +64,21 @@ TEST(CCLayerAnimationControllerImplTest, TrivialTransition) // Tests that two queued animations affecting the same property run in sequence. TEST(CCLayerAnimationControllerImplTest, TrivialQueuing) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 1, 0.5f)), 2, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5f)), 2, CCActiveAnimation::Opacity)); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(1); + controller->animate(1, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(1, dummy.opacity()); - controller->animate(2); + controller->animate(2, *events); EXPECT_EQ(0.5f, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -138,22 +86,23 @@ TEST(CCLayerAnimationControllerImplTest, TrivialQueuing) // Tests interrupting a transition with another transition. TEST(CCLayerAnimationControllerImplTest, Interrupt) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); - controller->animate(0); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 1, 0.5f)), 2, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5f)), 2, CCActiveAnimation::Opacity)); toAdd->setRunState(CCActiveAnimation::WaitingForNextTick, 0); controller->add(toAdd.release()); - controller->animate(0.5); // second anim starts NOW. + controller->animate(0.5, *events); // second anim starts NOW. EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(1, dummy.opacity()); - controller->animate(1.5); + controller->animate(1.5, *events); EXPECT_EQ(0.5f, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -161,23 +110,24 @@ TEST(CCLayerAnimationControllerImplTest, Interrupt) // Tests scheduling two animations to run together when only one property is free. TEST(CCLayerAnimationControllerImplTest, ScheduleTogetherWhenAPropertyIsBlocked) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeTransformTransition(1)), 1, CCActiveAnimation::Transform)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeTransformTransition(1)), 2, CCActiveAnimation::Transform)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 2, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), 1, CCActiveAnimation::Transform)); + controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), 2, CCActiveAnimation::Transform)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 2, CCActiveAnimation::Opacity)); - controller->animate(0); + controller->animate(0, *events); EXPECT_EQ(0, dummy.opacity()); EXPECT_TRUE(controller->hasActiveAnimation()); - controller->animate(1); + controller->animate(1, *events); // Should not have started the float transition yet. EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); // The the float animation should have started at time 1 and should be done. - controller->animate(2); + controller->animate(2, *events); EXPECT_EQ(1, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -187,29 +137,30 @@ TEST(CCLayerAnimationControllerImplTest, ScheduleTogetherWhenAPropertyIsBlocked) // for both to finish). TEST(CCLayerAnimationControllerImplTest, ScheduleTogetherWithAnAnimWaiting) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeTransformTransition(2)), 1, CCActiveAnimation::Transform)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 1, 0.5f)), 2, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(2)), 1, CCActiveAnimation::Transform)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5f)), 2, CCActiveAnimation::Opacity)); // Anims with id 1 should both start now. - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); // The opacity animation should have finished at time 1, but the group // of animations with id 1 don't finish until time 2 because of the length // of the transform animation. - controller->animate(2); + controller->animate(2, *events); // Should not have started the float transition yet. EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(1, dummy.opacity()); // The the second opacity animation should start at time 2 and should be // done by time 3 - controller->animate(3); + controller->animate(3, *events); EXPECT_EQ(0.5f, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -217,22 +168,23 @@ TEST(CCLayerAnimationControllerImplTest, ScheduleTogetherWithAnAnimWaiting) // Tests scheduling an animation to start in the future. TEST(CCLayerAnimationControllerImplTest, ScheduleAnimation) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); toAdd->setStartTime(1); controller->add(toAdd.release()); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(1); + controller->animate(1, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(2); + controller->animate(2, *events); EXPECT_EQ(1, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -240,28 +192,29 @@ TEST(CCLayerAnimationControllerImplTest, ScheduleAnimation) // Tests scheduling an animation to start in the future that's interrupting a running animation. TEST(CCLayerAnimationControllerImplTest, ScheduledAnimationInterruptsRunningAnimation) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity)); - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0.5f, 0)), 2, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0.5f, 0)), 2, CCActiveAnimation::Opacity)); toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); toAdd->setStartTime(1); controller->add(toAdd.release()); // First 2s opacity transition should start immediately. - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(0.5); + controller->animate(0.5, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.25f, dummy.opacity()); - controller->animate(1); + controller->animate(1, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.5f, dummy.opacity()); - controller->animate(2); + controller->animate(2, *events); EXPECT_EQ(0, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -270,34 +223,35 @@ TEST(CCLayerAnimationControllerImplTest, ScheduledAnimationInterruptsRunningAnim // and there is yet another animation queued to start later. TEST(CCLayerAnimationControllerImplTest, ScheduledAnimationInterruptsRunningAnimationWithAnimInQueue) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity)); - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(2, 0.5f, 0)), 2, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0.5f, 0)), 2, CCActiveAnimation::Opacity)); toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); toAdd->setStartTime(1); controller->add(toAdd.release()); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 0.75f)), 3, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 0.75f)), 3, CCActiveAnimation::Opacity)); // First 2s opacity transition should start immediately. - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(0.5); + controller->animate(0.5, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.25f, dummy.opacity()); EXPECT_TRUE(controller->hasActiveAnimation()); - controller->animate(1); + controller->animate(1, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.5f, dummy.opacity()); - controller->animate(3); + controller->animate(3, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(4); + controller->animate(4, *events); EXPECT_EQ(0.75f, dummy.opacity()); EXPECT_FALSE(controller->hasActiveAnimation()); } @@ -305,64 +259,66 @@ TEST(CCLayerAnimationControllerImplTest, ScheduledAnimationInterruptsRunningAnim // Test that a looping animation loops and for the correct number of iterations. TEST(CCLayerAnimationControllerImplTest, TrivialLooping) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); toAdd->setIterations(3); controller->add(toAdd.release()); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(1.25); + controller->animate(1.25, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.25f, dummy.opacity()); - controller->animate(1.75); + controller->animate(1.75, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.75f, dummy.opacity()); - controller->animate(2.25); + controller->animate(2.25, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.25f, dummy.opacity()); - controller->animate(2.75); + controller->animate(2.75, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.75f, dummy.opacity()); - controller->animate(3); + controller->animate(3, *events); EXPECT_FALSE(controller->hasActiveAnimation()); EXPECT_EQ(1, dummy.opacity()); // Just be extra sure. - controller->animate(4); + controller->animate(4, *events); EXPECT_EQ(1, dummy.opacity()); } // Test that an infinitely looping animation does indeed go until aborted. TEST(CCLayerAnimationControllerImplTest, InfiniteLooping) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); const int id = 1; - OwnPtr<CCActiveAnimation> toAdd(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity)); + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity)); toAdd->setIterations(-1); controller->add(toAdd.release()); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(1.25); + controller->animate(1.25, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.25f, dummy.opacity()); - controller->animate(1.75); + controller->animate(1.75, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.75f, dummy.opacity()); - controller->animate(1073741824.25); + controller->animate(1073741824.25, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.25f, dummy.opacity()); - controller->animate(1073741824.75); + controller->animate(1073741824.75, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.75f, dummy.opacity()); @@ -375,80 +331,66 @@ TEST(CCLayerAnimationControllerImplTest, InfiniteLooping) // Test that pausing and resuming work as expected. TEST(CCLayerAnimationControllerImplTest, PauseResume) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); const int id = 1; - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity)); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(0.5); + controller->animate(0.5, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.5f, dummy.opacity()); EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Paused, 0.5f); - controller->animate(1024); + controller->animate(1024, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.5f, dummy.opacity()); EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Running, 1024); - controller->animate(1024.25); + controller->animate(1024.25, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.75f, dummy.opacity()); - controller->animate(1024.5); + controller->animate(1024.5, *events); EXPECT_FALSE(controller->hasActiveAnimation()); EXPECT_EQ(1, dummy.opacity()); } TEST(CCLayerAnimationControllerImplTest, AbortAGroupedAnimation) { - FakeControllerClient dummy; + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerImplClient dummy; OwnPtr<CCLayerAnimationControllerImpl> controller( CCLayerAnimationControllerImpl::create(&dummy)); const int id = 1; - controller->add(CCActiveAnimation::create(adoptPtr(new FakeTransformTransition(1)), id, CCActiveAnimation::Transform)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(2, 0, 1)), id, CCActiveAnimation::Opacity)); - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 1, 0.75f)), 2, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), id, CCActiveAnimation::Transform)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), id, CCActiveAnimation::Opacity)); + controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.75f)), 2, CCActiveAnimation::Opacity)); - controller->animate(0); + controller->animate(0, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0, dummy.opacity()); - controller->animate(1); + controller->animate(1, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(0.5f, dummy.opacity()); EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Aborted, 1); - controller->animate(1); + controller->animate(1, *events); EXPECT_TRUE(controller->hasActiveAnimation()); EXPECT_EQ(1, dummy.opacity()); - controller->animate(2); + controller->animate(2, *events); EXPECT_TRUE(!controller->hasActiveAnimation()); EXPECT_EQ(0.75f, dummy.opacity()); } -// Tests that adding an animation to the controller calls the appropriate callback on the controller client -// (in this case, adding the controller to the list of active controller). -TEST(CCLayerAnimationControllerImplTest, DidActivate) -{ - FakeControllerClient dummy; - OwnPtr<CCLayerAnimationControllerImpl> controller( - CCLayerAnimationControllerImpl::create(&dummy)); - - EXPECT_EQ(size_t(0), dummy.activeControllers().size()); - - controller->add(CCActiveAnimation::create(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); - - EXPECT_EQ(size_t(1), dummy.activeControllers().size()); - EXPECT_EQ(controller.get(), dummy.activeControllers()[0]); -} - } // namespace diff --git a/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp b/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp new file mode 100644 index 000000000..c4f103a3c --- /dev/null +++ b/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp @@ -0,0 +1,215 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "cc/CCLayerAnimationController.h" + +#include "CCAnimationTestCommon.h" +#include "GraphicsLayer.h" +#include "Length.h" +#include "TranslateTransformOperation.h" +#include "cc/CCActiveAnimation.h" +#include "cc/CCAnimationCurve.h" + +#include <gmock/gmock.h> +#include <gtest/gtest.h> +#include <wtf/Vector.h> + +using namespace WebCore; +using namespace WebKitTests; + +namespace { + +void expectTranslateX(double translateX, const TransformationMatrix& matrix) +{ + TransformationMatrix::DecomposedType decomposedType; + matrix.decompose(decomposedType); + EXPECT_FLOAT_EQ(translateX, decomposedType.translateX); +} + +PassOwnPtr<CCActiveAnimation> createActiveAnimation(PassOwnPtr<CCAnimationCurve> curve, int id, CCActiveAnimation::TargetProperty property) +{ + return CCActiveAnimation::create(curve, 0, id, property); +} + +TEST(CCLayerAnimationControllerTest, createOpacityAnimation) +{ + OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create()); + const double duration = 1; + WebCore::KeyframeValueList values(AnimatedPropertyOpacity); + values.insert(new FloatAnimationValue(0, 0)); + values.insert(new FloatAnimationValue(duration, 1)); + + RefPtr<Animation> animation = Animation::create(); + animation->setDuration(duration); + + IntSize boxSize; + controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0); + + EXPECT_TRUE(controller->hasActiveAnimation()); + + CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCActiveAnimation::Opacity); + EXPECT_TRUE(activeAnimation); + + EXPECT_EQ(1, activeAnimation->iterations()); + EXPECT_EQ(CCActiveAnimation::Opacity, activeAnimation->targetProperty()); + + EXPECT_EQ(CCAnimationCurve::Float, activeAnimation->curve()->type()); + + const CCFloatAnimationCurve* curve = activeAnimation->curve()->toFloatAnimationCurve(); + EXPECT_TRUE(curve); + + EXPECT_EQ(0, curve->getValue(0)); + EXPECT_EQ(1, curve->getValue(duration)); +} + +TEST(CCLayerAnimationControllerTest, createTransformAnimation) +{ + OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create()); + const double duration = 1; + WebCore::KeyframeValueList values(AnimatedPropertyWebkitTransform); + + TransformOperations operations1; + operations1.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + values.insert(new TransformAnimationValue(0, &operations1)); + + TransformOperations operations2; + operations2.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X)); + values.insert(new TransformAnimationValue(duration, &operations2)); + + RefPtr<Animation> animation = Animation::create(); + animation->setDuration(duration); + + IntSize boxSize; + controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0); + + EXPECT_TRUE(controller->hasActiveAnimation()); + + CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCActiveAnimation::Transform); + EXPECT_TRUE(activeAnimation); + + EXPECT_EQ(1, activeAnimation->iterations()); + EXPECT_EQ(CCActiveAnimation::Transform, activeAnimation->targetProperty()); + + EXPECT_EQ(CCAnimationCurve::Transform, activeAnimation->curve()->type()); + + const CCTransformAnimationCurve* curve = activeAnimation->curve()->toTransformAnimationCurve(); + EXPECT_TRUE(curve); + + expectTranslateX(2, curve->getValue(0, boxSize)); + expectTranslateX(4, curve->getValue(duration, boxSize)); +} + +TEST(CCLayerAnimationControllerTest, syncNewAnimation) +{ + FakeLayerAnimationControllerImplClient dummy; + OwnPtr<CCLayerAnimationControllerImpl> controllerImpl(CCLayerAnimationControllerImpl::create(&dummy)); + OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create()); + + EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + + addOpacityTransitionToController(*controller, 1, 0, 1); + + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); +} + +TEST(CCLayerAnimationControllerTest, syncAnimationProperties) +{ + FakeLayerAnimationControllerImplClient dummy; + OwnPtr<CCLayerAnimationControllerImpl> controllerImpl(CCLayerAnimationControllerImpl::create(&dummy)); + OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create()); + + EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + + addOpacityTransitionToController(*controller, 1, 0, 1); + + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); + + // Push an animation property change to the impl thread (should not cause an animation to be added). + controller->pauseAnimation(0, 0); + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + EXPECT_EQ(CCActiveAnimation::Paused, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); +} + +TEST(CCLayerAnimationControllerTest, syncAbortedAnimation) +{ + FakeLayerAnimationControllerImplClient dummy; + OwnPtr<CCLayerAnimationControllerImpl> controllerImpl(CCLayerAnimationControllerImpl::create(&dummy)); + OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create()); + + EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + + addOpacityTransitionToController(*controller, 1, 0, 1); + + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); + + controller->removeAnimation(0); + + // Abort an animation from the main thread. + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); +} + +TEST(CCLayerAnimationControllerTest, syncCompletedAnimation) +{ + FakeLayerAnimationControllerImplClient dummy; + OwnPtr<CCLayerAnimationControllerImpl> controllerImpl(CCLayerAnimationControllerImpl::create(&dummy)); + OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create()); + + EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + + addOpacityTransitionToController(*controller, 1, 0, 1); + + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); + + // Step through the animation until it is finished. At the next sync, the main thread's animation should be cleared. + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + controllerImpl->animate(0, *events); + controllerImpl->animate(2, *events); + + EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)); + EXPECT_TRUE(controller->hasActiveAnimation()); + + controller->synchronizeAnimations(controllerImpl.get()); + + EXPECT_FALSE(controller->hasActiveAnimation()); +} + +} // namespace diff --git a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp index 27728cbef..16a25e12e 100644 --- a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp @@ -88,10 +88,13 @@ TEST(CCLayerImplTest, verifyLayerChangesAreTrackedProperly) Color arbitraryColor = Color(10, 20, 30); TransformationMatrix arbitraryTransform; arbitraryTransform.scale3d(0.1, 0.2, 0.3); + FilterOperations arbitraryFilters; + arbitraryFilters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY)); // Changing these properties affects the entire subtree of layers. EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setAnchorPoint(arbitraryFloatPoint)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setAnchorPointZ(arbitraryNumber)); + EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setFilters(arbitraryFilters)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setMaskLayer(dummyMask)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setMasksToBounds(true)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setOpaque(true)); diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp index b1fa72918..d2e1cfef9 100644 --- a/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp @@ -28,7 +28,6 @@ #include "CCLayerTreeTestCommon.h" #include "LayerChromium.h" -#include "Region.h" #include "TransformationMatrix.h" #include <gmock/gmock.h> @@ -36,12 +35,6 @@ using namespace WebCore; -#define EXPECT_EQ_RECT(a, b) \ - EXPECT_EQ(a.x(), b.x()); \ - EXPECT_EQ(a.y(), b.y()); \ - EXPECT_EQ(a.width(), b.width()); \ - EXPECT_EQ(a.height(), b.height()); - namespace { void setLayerPropertiesForTesting(LayerChromium* layer, const TransformationMatrix& transform, const TransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool preserves3D) @@ -602,174 +595,4 @@ TEST(CCLayerTreeHostCommonTest, verifyClipRectCullsRenderSurfaces) // - test the other functions in CCLayerTreeHostCommon // -TEST(CCLayerTreeHostCommonTest, layerAddsSelfToOccludedRegion) -{ - // This tests that the right transforms are being used. - Region occluded; - const TransformationMatrix identityMatrix; - RefPtr<LayerChromium> parent = LayerChromium::create(); - RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); - parent->createRenderSurface(); - parent->addChild(layer); - - setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); - setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); - - layer->setOpaque(true); - - Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; - Vector<RefPtr<LayerChromium> > dummyLayerList; - int dummyMaxTextureSize = 512; - - // FIXME: when we fix this "root-layer special case" behavior in CCLayerTreeHost, we will have to fix it here, too. - parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); - parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); - renderSurfaceLayerList.append(parent); - - CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); - - occluded = Region(); - layer->addSelfToOccludedScreenSpace(occluded); - EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occluded.bounds()); - EXPECT_EQ(1u, occluded.rects().size()); -} - -TEST(CCLayerTreeHostCommonTest, layerAddsSelfToOccludedRegionWithRotation) -{ - // This tests that the right transforms are being used. - Region occluded; - const TransformationMatrix identityMatrix; - RefPtr<LayerChromium> parent = LayerChromium::create(); - RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); - parent->createRenderSurface(); - parent->addChild(layer); - - TransformationMatrix layerTransform; - layerTransform.translate(250, 250); - layerTransform.rotate(90); - layerTransform.translate(-250, -250); - - setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); - setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); - - layer->setOpaque(true); - - Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; - Vector<RefPtr<LayerChromium> > dummyLayerList; - int dummyMaxTextureSize = 512; - - // FIXME: when we fix this "root-layer special case" behavior in CCLayerTreeHost, we will have to fix it here, too. - parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); - parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); - renderSurfaceLayerList.append(parent); - - CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); - - occluded = Region(); - layer->addSelfToOccludedScreenSpace(occluded); - EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occluded.bounds()); - EXPECT_EQ(1u, occluded.rects().size()); -} - -TEST(CCLayerTreeHostCommonTest, layerAddsSelfToOccludedRegionWithTranslation) -{ - // This tests that the right transforms are being used. - Region occluded; - const TransformationMatrix identityMatrix; - RefPtr<LayerChromium> parent = LayerChromium::create(); - RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); - parent->createRenderSurface(); - parent->addChild(layer); - - TransformationMatrix layerTransform; - layerTransform.translate(20, 20); - - setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); - setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); - - layer->setOpaque(true); - - Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; - Vector<RefPtr<LayerChromium> > dummyLayerList; - int dummyMaxTextureSize = 512; - - // FIXME: when we fix this "root-layer special case" behavior in CCLayerTreeHost, we will have to fix it here, too. - parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); - parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); - renderSurfaceLayerList.append(parent); - - CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); - - occluded = Region(); - layer->addSelfToOccludedScreenSpace(occluded); - EXPECT_EQ_RECT(IntRect(50, 50, 50, 50), occluded.bounds()); - EXPECT_EQ(1u, occluded.rects().size()); -} - -TEST(CCLayerTreeHostCommonTest, layerAddsSelfToOccludedRegionWithRotatedSurface) -{ - // This tests that the right transforms are being used. - Region occluded; - const TransformationMatrix identityMatrix; - RefPtr<LayerChromium> parent = LayerChromium::create(); - RefPtr<LayerChromium> child = LayerChromium::create(); - RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); - parent->createRenderSurface(); - parent->addChild(child); - child->addChild(layer); - - TransformationMatrix childTransform; - childTransform.translate(250, 250); - childTransform.rotate(90); - childTransform.translate(-250, -250); - - setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); - setLayerPropertiesForTesting(child.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); - setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(10, 10), IntSize(500, 500), false); - - child->setMasksToBounds(true); - layer->setOpaque(true); - - Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; - Vector<RefPtr<LayerChromium> > dummyLayerList; - int dummyMaxTextureSize = 512; - - // FIXME: when we fix this "root-layer special case" behavior in CCLayerTreeHost, we will have to fix it here, too. - parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); - parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); - renderSurfaceLayerList.append(parent); - - CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); - - occluded = Region(); - layer->addSelfToOccludedScreenSpace(occluded); - EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occluded.bounds()); - EXPECT_EQ(1u, occluded.rects().size()); - - /* Justification for the above opaque rect from |layer|: - 100 - +---------------------+ +---------------------+ - | | | |30 Visible region of |layer|: ///// - | 30 | rotate(90) | | - | 30 + ---------------------------------+ | +---------------------------------+ - 100 | | 10 | | ==> | | |10 | - | |10+---------------------------------+ | +---------------------------------+ | - | | | | | | | | |///////////////| 420 | | - | | | | | | | | |///////////////|60 | | - | | | | | | | | |///////////////| | | - +----|--|-------------+ | | +--|--|---------------+ | | - | | | | 20|10| 70 | | - | | | | | | | | - | | | |500 | | | | - | | | | | | | | - | | | | | | | | - | | | | | | | | - | | | | | | |10| - +--|-------------------------------+ | | +------------------------------|--+ - | | | 490 | - +---------------------------------+ +---------------------------------+ - 500 500 - */ -} - } // namespace diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp index f59893de9..9ba1cf4ad 100644 --- a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp @@ -52,6 +52,7 @@ public: virtual void onSwapBuffersCompleteOnImplThread() { } virtual void setNeedsRedrawOnImplThread() { m_didRequestRedraw = true; } virtual void setNeedsCommitOnImplThread() { m_didRequestCommit = true; } + virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>) { } static void expectClearedScrollDeltasRecursive(CCLayerImpl* layer) { @@ -67,7 +68,8 @@ public: for (size_t i = 0; i < scrollInfo.scrolls.size(); ++i) { if (scrollInfo.scrolls[i].layerId != id) continue; - ASSERT_EQ(scrollInfo.scrolls[i].scrollDelta, scrollDelta); + EXPECT_EQ(scrollDelta.width(), scrollInfo.scrolls[i].scrollDelta.width()); + EXPECT_EQ(scrollDelta.height(), scrollInfo.scrolls[i].scrollDelta.height()); timesEncountered++; } @@ -89,6 +91,11 @@ public: } protected: + PassRefPtr<GraphicsContext3D> createContext() + { + return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new FakeWebGraphicsContext3D()), GraphicsContext3D::RenderDirectlyToHostWindow); + } + DebugScopedSetImplThread m_alwaysImplThread; OwnPtr<CCLayerTreeHostImpl> m_hostImpl; bool m_didRequestCommit; @@ -142,14 +149,14 @@ TEST_F(CCLayerTreeHostImplTest, scrollDeltaRepeatedScrolls) scrollInfo = m_hostImpl->processScrollDeltas(); ASSERT_EQ(scrollInfo->scrolls.size(), 1u); EXPECT_EQ(root->sentScrollDelta(), scrollDelta); - expectContains(*scrollInfo.get(), root->id(), scrollDelta); + expectContains(*scrollInfo, root->id(), scrollDelta); IntSize scrollDelta2(-5, 27); root->scrollBy(scrollDelta2); scrollInfo = m_hostImpl->processScrollDeltas(); ASSERT_EQ(scrollInfo->scrolls.size(), 1u); EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2); - expectContains(*scrollInfo.get(), root->id(), scrollDelta + scrollDelta2); + expectContains(*scrollInfo, root->id(), scrollDelta + scrollDelta2); root->scrollBy(IntSize()); scrollInfo = m_hostImpl->processScrollDeltas(); @@ -163,13 +170,28 @@ TEST_F(CCLayerTreeHostImplTest, scrollRootCallsCommitAndRedraw) root->setScrollPosition(IntPoint(0, 0)); root->setMaxScrollPosition(IntSize(100, 100)); m_hostImpl->setRootLayer(root); - EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0)), CCInputHandlerClient::ScrollStarted); + EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted); m_hostImpl->scrollBy(IntSize(0, 10)); m_hostImpl->scrollEnd(); EXPECT_TRUE(m_didRequestRedraw); EXPECT_TRUE(m_didRequestCommit); } +TEST_F(CCLayerTreeHostImplTest, wheelEventHandlers) +{ + RefPtr<CCLayerImpl> root = CCLayerImpl::create(0); + root->setScrollable(true); + root->setScrollPosition(IntPoint(0, 0)); + root->setMaxScrollPosition(IntSize(100, 100)); + m_hostImpl->setRootLayer(root); + root->setHaveWheelEventHandlers(true); + // With registered event handlers, wheel scrolls have to go to the main thread. + EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed); + + // But gesture scrolls can still be handled. + EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted); +} + TEST_F(CCLayerTreeHostImplTest, pinchGesture) { setupScrollAndContentsLayers(IntSize(100, 100)); @@ -184,6 +206,7 @@ TEST_F(CCLayerTreeHostImplTest, pinchGesture) { m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale); scrollLayer->setPageScaleDelta(1); + scrollLayer->setScrollDelta(IntSize()); float pageScaleDelta = 2; m_hostImpl->pinchGestureBegin(); @@ -200,6 +223,7 @@ TEST_F(CCLayerTreeHostImplTest, pinchGesture) { m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale); scrollLayer->setPageScaleDelta(1); + scrollLayer->setScrollDelta(IntSize()); float pageScaleDelta = 10; m_hostImpl->pinchGestureBegin(); @@ -214,6 +238,7 @@ TEST_F(CCLayerTreeHostImplTest, pinchGesture) { m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale); scrollLayer->setPageScaleDelta(1); + scrollLayer->setScrollDelta(IntSize()); scrollLayer->setScrollPosition(IntPoint(50, 50)); float pageScaleDelta = 0.1; @@ -225,7 +250,25 @@ TEST_F(CCLayerTreeHostImplTest, pinchGesture) EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale); // Pushed to (0,0) via clamping against contents layer size. - expectContains(*scrollInfo.get(), scrollLayer->id(), IntSize(-50, -50)); + expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50)); + } + + // Two-finger panning + { + m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale); + scrollLayer->setPageScaleDelta(1); + scrollLayer->setScrollDelta(IntSize()); + scrollLayer->setScrollPosition(IntPoint(20, 20)); + + float pageScaleDelta = 1; + m_hostImpl->pinchGestureBegin(); + m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(10, 10)); + m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(20, 20)); + m_hostImpl->pinchGestureEnd(); + + OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas(); + EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta); + expectContains(*scrollInfo, scrollLayer->id(), IntSize(-10, -10)); } } @@ -255,7 +298,7 @@ TEST_F(CCLayerTreeHostImplTest, pageScaleAnimation) OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas(); EXPECT_EQ(scrollInfo->pageScaleDelta, 2); - expectContains(*scrollInfo.get(), scrollLayer->id(), IntSize(-50, -50)); + expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50)); } // Anchor zoom-out @@ -272,8 +315,107 @@ TEST_F(CCLayerTreeHostImplTest, pageScaleAnimation) OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas(); EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale); // Pushed to (0,0) via clamping against contents layer size. - expectContains(*scrollInfo.get(), scrollLayer->id(), IntSize(-50, -50)); + expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50)); + } +} + +class DidDrawCheckLayer : public CCLayerImpl { +public: + static PassRefPtr<DidDrawCheckLayer> create(int id) { return adoptRef(new DidDrawCheckLayer(id)); } + + virtual void didDraw() + { + m_didDrawCalled = true; + } + + virtual void willDraw(LayerRendererChromium*) + { + m_willDrawCalled = true; + } + + bool didDrawCalled() const { return m_didDrawCalled; } + bool willDrawCalled() const { return m_willDrawCalled; } + +private: + explicit DidDrawCheckLayer(int id) + : CCLayerImpl(id) + , m_didDrawCalled(false) + , m_willDrawCalled(false) + { + setAnchorPoint(FloatPoint(0, 0)); + setBounds(IntSize(10, 10)); + setDrawsContent(true); } + + bool m_didDrawCalled; + bool m_willDrawCalled; +}; + +TEST_F(CCLayerTreeHostImplTest, didDrawNotCalledOnHiddenLayer) +{ + RefPtr<GraphicsContext3D> context = createContext(); + m_hostImpl->initializeLayerRenderer(context); + + // Ensure visibleLayerRect for root layer is empty + m_hostImpl->setViewportSize(IntSize(0, 0)); + + RefPtr<DidDrawCheckLayer> root = DidDrawCheckLayer::create(0); + m_hostImpl->setRootLayer(root); + + EXPECT_FALSE(root->willDrawCalled()); + EXPECT_FALSE(root->didDrawCalled()); + + m_hostImpl->drawLayers(); + + EXPECT_FALSE(root->willDrawCalled()); + EXPECT_FALSE(root->didDrawCalled()); + + EXPECT_TRUE(root->visibleLayerRect().isEmpty()); + + // Ensure visibleLayerRect for root layer is not empty + m_hostImpl->setViewportSize(IntSize(10, 10)); + + EXPECT_FALSE(root->willDrawCalled()); + EXPECT_FALSE(root->didDrawCalled()); + + m_hostImpl->drawLayers(); + + EXPECT_TRUE(root->willDrawCalled()); + EXPECT_TRUE(root->didDrawCalled()); + + EXPECT_FALSE(root->visibleLayerRect().isEmpty()); +} + +TEST_F(CCLayerTreeHostImplTest, didDrawCalledOnAllLayers) +{ + RefPtr<GraphicsContext3D> context = createContext(); + m_hostImpl->initializeLayerRenderer(context); + m_hostImpl->setViewportSize(IntSize(10, 10)); + + RefPtr<DidDrawCheckLayer> root = DidDrawCheckLayer::create(0); + m_hostImpl->setRootLayer(root); + + RefPtr<DidDrawCheckLayer> layer1 = DidDrawCheckLayer::create(1); + root->addChild(layer1); + + RefPtr<DidDrawCheckLayer> layer2 = DidDrawCheckLayer::create(2); + layer1->addChild(layer2); + + layer1->setOpacity(0.3); + layer1->setPreserves3D(false); + + EXPECT_FALSE(root->didDrawCalled()); + EXPECT_FALSE(layer1->didDrawCalled()); + EXPECT_FALSE(layer2->didDrawCalled()); + + m_hostImpl->drawLayers(); + + EXPECT_TRUE(root->didDrawCalled()); + EXPECT_TRUE(layer1->didDrawCalled()); + EXPECT_TRUE(layer2->didDrawCalled()); + + EXPECT_NE(root->renderSurface(), layer1->renderSurface()); + EXPECT_TRUE(!!layer1->renderSurface()); } class BlendStateTrackerContext: public FakeWebGraphicsContext3D { @@ -347,8 +489,7 @@ private: // https://bugs.webkit.org/show_bug.cgi?id=75783 TEST_F(CCLayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers) { - GraphicsContext3D::Attributes attrs; - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new BlendStateTrackerContext()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> context = createContext(); m_hostImpl->initializeLayerRenderer(context); m_hostImpl->setViewportSize(IntSize(10, 10)); @@ -507,7 +648,6 @@ private: class FakeDrawableCCLayerImpl: public CCLayerImpl { public: explicit FakeDrawableCCLayerImpl(int id) : CCLayerImpl(id) { } - virtual void draw(LayerRendererChromium* renderer) { } }; // Only reshape when we know we are going to draw. Otherwise, the reshape @@ -515,9 +655,8 @@ public: // viewport size is never set. TEST_F(CCLayerTreeHostImplTest, reshapeNotCalledUntilDraw) { - GraphicsContext3D::Attributes attrs; ReshapeTrackerContext* reshapeTracker = new ReshapeTrackerContext(); - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(reshapeTracker), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(reshapeTracker), GraphicsContext3D::RenderDirectlyToHostWindow); m_hostImpl->initializeLayerRenderer(context); m_hostImpl->setViewportSize(IntSize(10, 10)); @@ -559,9 +698,8 @@ private: // where it should request to swap only the subBuffer that is damaged. TEST_F(CCLayerTreeHostImplTest, partialSwapReceivesDamageRect) { - GraphicsContext3D::Attributes attrs; PartialSwapTrackerContext* partialSwapTracker = new PartialSwapTrackerContext(); - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(partialSwapTracker), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(partialSwapTracker), GraphicsContext3D::RenderDirectlyToHostWindow); // This test creates its own CCLayerTreeHostImpl, so // that we can force partial swap enabled. diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp index fc414f739..10cfa6931 100644 --- a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp @@ -26,14 +26,18 @@ #include "cc/CCLayerTreeHost.h" +#include "CCAnimationTestCommon.h" #include "CompositorFakeWebGraphicsContext3D.h" #include "ContentLayerChromium.h" +#include "FilterOperations.h" #include "GraphicsContext3DPrivate.h" #include "LayerChromium.h" #include "Region.h" #include "TextureManager.h" #include "WebCompositor.h" #include "WebKit.h" +#include "cc/CCActiveAnimation.h" +#include "cc/CCLayerAnimationController.h" #include "cc/CCLayerImpl.h" #include "cc/CCLayerTreeHostImpl.h" #include "cc/CCScopedThreadProxy.h" @@ -49,6 +53,7 @@ using namespace WebCore; using namespace WebKit; +using namespace WebKitTests; using namespace WTF; namespace { @@ -59,6 +64,7 @@ public: virtual void beginCommitOnCCThread(CCLayerTreeHostImpl*) { } virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl*) { } virtual void drawLayersOnCCThread(CCLayerTreeHostImpl*) { } + virtual void animateLayers(CCLayerTreeHostImpl*) { } virtual void applyScrollAndScale(const IntSize&, float) { } virtual void updateAnimations(double frameBeginTime) { } virtual void layout() { } @@ -90,6 +96,13 @@ public: m_testHooks->drawLayersOnCCThread(this); } +protected: + virtual void animateLayers(double frameBeginTimeMs) + { + CCLayerTreeHostImpl::animateLayers(frameBeginTimeMs); + m_testHooks->animateLayers(this); + } + private: MockLayerTreeHostImpl(TestHooks* testHooks, const CCSettings& settings, CCLayerTreeHostImplClient* client) : CCLayerTreeHostImpl(settings, client) @@ -105,7 +118,11 @@ class MockLayerTreeHost : public CCLayerTreeHost { public: static PassRefPtr<MockLayerTreeHost> create(TestHooks* testHooks, CCLayerTreeHostClient* client, PassRefPtr<LayerChromium> rootLayer, const CCSettings& settings) { - RefPtr<MockLayerTreeHost> layerTreeHost = adoptRef(new MockLayerTreeHost(testHooks, client, settings)); + // For these tests, we will enable threaded animations. + CCSettings settingsCopy = settings; + settingsCopy.threadedAnimationEnabled = true; + + RefPtr<MockLayerTreeHost> layerTreeHost = adoptRef(new MockLayerTreeHost(testHooks, client, settingsCopy)); bool success = layerTreeHost->initialize(); EXPECT_TRUE(success); layerTreeHost->setRootLayer(rootLayer); @@ -118,7 +135,10 @@ public: virtual PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHostImpl(CCLayerTreeHostImplClient* client) { - return MockLayerTreeHostImpl::create(m_testHooks, settings(), client); + // For these tests, we will enable threaded animations. + CCSettings settings; + settings.threadedAnimationEnabled = true; + return MockLayerTreeHostImpl::create(m_testHooks, settings, client); } private: @@ -207,10 +227,7 @@ public: webAttrs.alpha = attrs.alpha; OwnPtr<WebGraphicsContext3D> webContext = CompositorFakeWebGraphicsContext3DWithTextureTracking::create(webAttrs); - return GraphicsContext3DPrivate::createGraphicsContextFromWebContext( - webContext.release(), attrs, 0, - GraphicsContext3D::RenderDirectlyToHostWindow, - GraphicsContext3DPrivate::ForUseOnAnotherThread); + return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), GraphicsContext3D::RenderDirectlyToHostWindow); } virtual void didCommitAndDrawFrame() @@ -225,7 +242,9 @@ public: { } - virtual void scheduleComposite() { } + virtual void scheduleComposite() + { + } private: explicit MockLayerTreeHostClient(TestHooks* testHooks) : m_testHooks(testHooks) { } @@ -255,6 +274,11 @@ public: callOnMainThread(CCLayerTreeHostTest::dispatchSetNeedsAnimate, this); } + void postAddAnimationToMainThread() + { + callOnMainThread(CCLayerTreeHostTest::dispatchAddAnimation, this); + } + void postSetNeedsCommitToMainThread() { callOnMainThread(CCLayerTreeHostTest::dispatchSetNeedsCommit, this); @@ -270,7 +294,6 @@ public: callOnMainThread(CCLayerTreeHostTest::dispatchSetNeedsAnimateAndCommit, this); } - void postSetVisibleToMainThread(bool visible) { callOnMainThread(visible ? CCLayerTreeHostTest::dispatchSetVisible : CCLayerTreeHostTest::dispatchSetInvisible, this); @@ -313,6 +336,15 @@ protected: test->m_layerTreeHost->setNeedsAnimate(); } + static void dispatchAddAnimation(void* self) + { + ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); + ASSERT(test); + if (test->m_layerTreeHost && test->m_layerTreeHost->rootLayer()) + addOpacityTransitionToLayer(*test->m_layerTreeHost->rootLayer(), 0, 0, 1); + } + static void dispatchSetNeedsAnimateAndCommit(void* self) { ASSERT(isMainThread()); @@ -789,6 +821,47 @@ TEST_F(CCLayerTreeHostTestSetNeedsAnimateInsideAnimationCallback, runMultiThread runTestThreaded(); } +// Add a layer animation and confirm that CCLayerTreeHostImpl::animateLayers does get +// called and continues to get called. +class CCLayerTreeHostTestAddAnimation : public CCLayerTreeHostTestThreadOnly { +public: + CCLayerTreeHostTestAddAnimation() + : m_numAnimates(0) + , m_layerTreeHostImpl(0) + { + } + + virtual void beginTest() + { + postAddAnimationToMainThread(); + } + + virtual void animateLayers(CCLayerTreeHostImpl* layerTreeHostImpl) + { + if (!m_numAnimates) { + // The animation had zero duration so layerTreeHostImpl should no + // longer need to animate its layers. + EXPECT_FALSE(layerTreeHostImpl->needsAnimateLayers()); + m_numAnimates++; + return; + } + endTest(); + } + + virtual void afterTest() + { + } + +private: + int m_numAnimates; + CCLayerTreeHostImpl* m_layerTreeHostImpl; +}; + +TEST_F(CCLayerTreeHostTestAddAnimation, runMultiThread) +{ + runTestThreaded(); +} + class CCLayerTreeHostTestScrollSimple : public CCLayerTreeHostTestThreadOnly { public: CCLayerTreeHostTestScrollSimple() @@ -938,6 +1011,75 @@ TEST_F(CCLayerTreeHostTestScrollMultipleRedraw, DISABLED_runMultiThread) runTestThreaded(); } +// Verifies that startPageScaleAnimation events propagate correctly from CCLayerTreeHost to +// CCLayerTreeHostImpl in the MT compositor. +class CCLayerTreeHostTestStartPageScaleAnimation : public CCLayerTreeHostTest { +public: + + CCLayerTreeHostTestStartPageScaleAnimation() + : m_animationRequested(false) + { + } + + virtual void beginTest() + { + m_layerTreeHost->rootLayer()->setScrollable(true); + m_layerTreeHost->rootLayer()->setScrollPosition(IntPoint()); + postSetNeedsRedrawToMainThread(); + } + + static void requestStartPageScaleAnimation(void* self) + { + CCLayerTreeHostTestStartPageScaleAnimation* test = static_cast<CCLayerTreeHostTestStartPageScaleAnimation*>(self); + if (test->layerTreeHost()) + test->layerTreeHost()->startPageScaleAnimation(IntSize(), false, 1.25, 0); + } + + virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl) + { + impl->rootLayer()->setScrollable(true); + impl->rootLayer()->setScrollPosition(IntPoint()); + impl->setPageScaleFactorAndLimits(impl->pageScale(), 0.5, 2); + + // We request animation only once. + if (!m_animationRequested) { + callOnMainThread(CCLayerTreeHostTestStartPageScaleAnimation::requestStartPageScaleAnimation, this); + m_animationRequested = true; + } + } + + virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale) + { + IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition(); + m_layerTreeHost->rootLayer()->setScrollPosition(position + scrollDelta); + m_layerTreeHost->setPageScaleFactorAndLimits(scale, 0.5, 2); + } + + virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl* impl) + { + impl->processScrollDeltas(); + // We get one commit before the first draw, and the animation doesn't happen until the second draw, + // so results available on the third commit. + if (impl->frameNumber() == 2) { + EXPECT_EQ(1.25, impl->pageScale()); + endTest(); + } else + postSetNeedsRedrawToMainThread(); + } + + virtual void afterTest() + { + } + +private: + bool m_animationRequested; +}; + +TEST_F(CCLayerTreeHostTestStartPageScaleAnimation, runTest) +{ + runTest(true); +} + class CCLayerTreeHostTestSetVisible : public CCLayerTreeHostTest { public: @@ -1596,6 +1738,94 @@ public: SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestLayerOcclusion) +class CCLayerTreeHostTestLayerOcclusionWithFilters : public CCLayerTreeHostTest { +public: + CCLayerTreeHostTestLayerOcclusionWithFilters() { } + + virtual void beginTest() + { + RefPtr<TestLayerChromium> rootLayer = TestLayerChromium::create(); + RefPtr<TestLayerChromium> child = TestLayerChromium::create(); + RefPtr<TestLayerChromium> child2 = TestLayerChromium::create(); + RefPtr<TestLayerChromium> grandChild = TestLayerChromium::create(); + RefPtr<TestLayerChromium> mask = TestLayerChromium::create(); + + TransformationMatrix identityMatrix; + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(90); + childTransform.translate(-250, -250); + + child->setMasksToBounds(true); + + // If the child layer has a filter that changes alpha values, and is below child2, then child2 should contribute to occlusion on everything, + // and child shouldn't contribute to the rootLayer + setLayerPropertiesForTesting(rootLayer.get(), 0, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); + setLayerPropertiesForTesting(child.get(), rootLayer.get(), childTransform, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + setLayerPropertiesForTesting(grandChild.get(), child.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(10, 10), IntSize(500, 500), true); + setLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(10, 70), IntSize(500, 500), true); + + { + FilterOperations filters; + filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY)); + child->setFilters(filters); + } + + m_layerTreeHost->setRootLayer(rootLayer); + m_layerTreeHost->setViewportSize(rootLayer->bounds()); + m_layerTreeHost->updateLayers(); + m_layerTreeHost->commitComplete(); + + EXPECT_EQ_RECT(IntRect(), child2->occludedScreenSpace().bounds()); + EXPECT_EQ(0u, child2->occludedScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 70, 90, 30), grandChild->occludedScreenSpace().bounds()); + EXPECT_EQ(1u, grandChild->occludedScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 40, 90, 60), child->occludedScreenSpace().bounds()); + EXPECT_EQ(2u, child->occludedScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 70, 90, 30), rootLayer->occludedScreenSpace().bounds()); + EXPECT_EQ(1u, rootLayer->occludedScreenSpace().rects().size()); + + // If the child layer has a filter that moves pixels/changes alpha, and is below child2, then child should not inherit occlusion from outside its subtree, + // and should not contribute to the rootLayer + setLayerPropertiesForTesting(rootLayer.get(), 0, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); + setLayerPropertiesForTesting(child.get(), rootLayer.get(), childTransform, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + setLayerPropertiesForTesting(grandChild.get(), child.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(10, 10), IntSize(500, 500), true); + setLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(10, 70), IntSize(500, 500), true); + + { + FilterOperations filters; + filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Percent), FilterOperation::BLUR)); + child->setFilters(filters); + } + + m_layerTreeHost->setRootLayer(rootLayer); + m_layerTreeHost->setViewportSize(rootLayer->bounds()); + m_layerTreeHost->updateLayers(); + m_layerTreeHost->commitComplete(); + + EXPECT_EQ_RECT(IntRect(), child2->occludedScreenSpace().bounds()); + EXPECT_EQ(0u, child2->occludedScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(), grandChild->occludedScreenSpace().bounds()); + EXPECT_EQ(0u, grandChild->occludedScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), child->occludedScreenSpace().bounds()); + EXPECT_EQ(1u, child->occludedScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 70, 90, 30), rootLayer->occludedScreenSpace().bounds()); + EXPECT_EQ(1u, rootLayer->occludedScreenSpace().rects().size()); + + // Kill the layerTreeHost immediately. + m_layerTreeHost->setRootLayer(0); + m_layerTreeHost.clear(); + + endTest(); + } + + virtual void afterTest() + { + } +}; + +SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestLayerOcclusionWithFilters) + class CCLayerTreeHostTestManySurfaces : public CCLayerTreeHostTest { public: CCLayerTreeHostTestManySurfaces() { } diff --git a/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp b/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp new file mode 100644 index 000000000..678ec9645 --- /dev/null +++ b/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp @@ -0,0 +1,1173 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "cc/CCOcclusionTracker.h" + +#include "FilterOperations.h" +#include "LayerChromium.h" +#include "Region.h" +#include "TransformationMatrix.h" +#include "cc/CCLayerTreeHostCommon.h" + +#include <gmock/gmock.h> +#include <gtest/gtest.h> + +using namespace WebCore; + +#define EXPECT_EQ_RECT(a, b) \ + EXPECT_EQ(a.x(), b.x()); \ + EXPECT_EQ(a.y(), b.y()); \ + EXPECT_EQ(a.width(), b.width()); \ + EXPECT_EQ(a.height(), b.height()); + +namespace { + +void setLayerPropertiesForTesting(LayerChromium* layer, const TransformationMatrix& transform, const TransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool opaque) +{ + layer->setTransform(transform); + layer->setSublayerTransform(sublayerTransform); + layer->setAnchorPoint(anchor); + layer->setPosition(position); + layer->setBounds(bounds); + layer->setOpaque(opaque); +} + +class LayerChromiumWithForcedDrawsContent : public LayerChromium { +public: + LayerChromiumWithForcedDrawsContent() + : LayerChromium() + { + } + + virtual bool drawsContent() const { return true; } +}; + +// A subclass to expose the total current occlusion. +class TestCCOcclusionTracker : public CCOcclusionTracker { +public: + Region occlusionInScreenSpace() const { return CCOcclusionTracker::m_stack.last().occlusionInScreen; } + Region occlusionInTargetSurface() const { return CCOcclusionTracker::m_stack.last().occlusionInTarget; } + + void setOcclusionInScreenSpace(const Region& region) { CCOcclusionTracker::m_stack.last().occlusionInScreen = region; } + void setOcclusionInTargetSurface(const Region& region) { CCOcclusionTracker::m_stack.last().occlusionInTarget = region; } +}; + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegion) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(layer); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(parent->renderSurface()); + occlusion.markOccludedBehindLayer(layer.get()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 29, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(31, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 31, 70, 70))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(30, 30, 70, 70)).isEmpty()); + EXPECT_EQ_RECT(IntRect(29, 30, 1, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 30, 70, 70))); + EXPECT_EQ_RECT(IntRect(29, 29, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 29, 70, 70))); + EXPECT_EQ_RECT(IntRect(30, 29, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 29, 70, 70))); + EXPECT_EQ_RECT(IntRect(31, 29, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 29, 70, 70))); + EXPECT_EQ_RECT(IntRect(100, 30, 1, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 30, 70, 70))); + EXPECT_EQ_RECT(IntRect(31, 31, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 31, 70, 70))); + EXPECT_EQ_RECT(IntRect(30, 100, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 31, 70, 70))); + EXPECT_EQ_RECT(IntRect(29, 31, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 31, 70, 70))); +} + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegionWithRotation) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(layer); + + TransformationMatrix layerTransform; + layerTransform.translate(250, 250); + layerTransform.rotate(90); + layerTransform.translate(-250, -250); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(parent->renderSurface()); + occlusion.markOccludedBehindLayer(layer.get()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 29, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(31, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 31, 70, 70))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(30, 30, 70, 70)).isEmpty()); + EXPECT_EQ_RECT(IntRect(29, 30, 1, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 30, 70, 70))); + EXPECT_EQ_RECT(IntRect(29, 29, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 29, 70, 70))); + EXPECT_EQ_RECT(IntRect(30, 29, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 29, 70, 70))); + EXPECT_EQ_RECT(IntRect(31, 29, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 29, 70, 70))); + EXPECT_EQ_RECT(IntRect(100, 30, 1, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 30, 70, 70))); + EXPECT_EQ_RECT(IntRect(31, 31, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 31, 70, 70))); + EXPECT_EQ_RECT(IntRect(30, 100, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 31, 70, 70))); + EXPECT_EQ_RECT(IntRect(29, 31, 70, 70), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 31, 70, 70))); +} + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegionWithTranslation) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(layer); + + TransformationMatrix layerTransform; + layerTransform.translate(20, 20); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(parent->renderSurface()); + occlusion.markOccludedBehindLayer(layer.get()); + EXPECT_EQ_RECT(IntRect(50, 50, 50, 50), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(50, 50, 50, 50), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(50, 50, 50, 50))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(49, 50, 50, 50))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(50, 49, 50, 50))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(51, 50, 50, 50))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(50, 51, 50, 50))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(50, 50, 50, 50)).isEmpty()); + EXPECT_EQ_RECT(IntRect(49, 50, 1, 50), occlusion.unoccludedContentRect(parent.get(), IntRect(49, 50, 50, 50))); + EXPECT_EQ_RECT(IntRect(49, 49, 50, 50), occlusion.unoccludedContentRect(parent.get(), IntRect(49, 49, 50, 50))); + EXPECT_EQ_RECT(IntRect(50, 49, 50, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(50, 49, 50, 50))); + EXPECT_EQ_RECT(IntRect(51, 49, 50, 50), occlusion.unoccludedContentRect(parent.get(), IntRect(51, 49, 50, 50))); + EXPECT_EQ_RECT(IntRect(100, 50, 1, 50), occlusion.unoccludedContentRect(parent.get(), IntRect(51, 50, 50, 50))); + EXPECT_EQ_RECT(IntRect(51, 51, 50, 50), occlusion.unoccludedContentRect(parent.get(), IntRect(51, 51, 50, 50))); + EXPECT_EQ_RECT(IntRect(50, 100, 50, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(50, 51, 50, 50))); + EXPECT_EQ_RECT(IntRect(49, 51, 50, 50), occlusion.unoccludedContentRect(parent.get(), IntRect(49, 51, 50, 50))); +} + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegionWithRotatedSurface) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child); + child->addChild(layer); + + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(90); + childTransform.translate(-250, -250); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); + setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(10, 10), IntSize(500, 500), true); + + child->setMasksToBounds(true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(child->renderSurface()); + occlusion.markOccludedBehindLayer(layer.get()); + + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 430, 60, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child.get(), IntRect(10, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(9, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 429, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 430, 61, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 430, 60, 71))); + + occlusion.markOccludedBehindLayer(child.get()); + occlusion.finishedTargetRenderSurface(child.get(), child->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 40, 70, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 40, 70, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 39, 70, 60))); + + + /* Justification for the above occlusion from |layer|: + 100 + +---------------------+ +---------------------+ + | | | |30 Visible region of |layer|: ///// + | 30 | rotate(90) | | + | 30 + ---------------------------------+ | +---------------------------------+ + 100 | | 10 | | ==> | | |10 | + | |10+---------------------------------+ | +---------------------------------+ | + | | | | | | | | |///////////////| 420 | | + | | | | | | | | |///////////////|60 | | + | | | | | | | | |///////////////| | | + +----|--|-------------+ | | +--|--|---------------+ | | + | | | | 20|10| 70 | | + | | | | | | | | + | | | |500 | | | | + | | | | | | | | + | | | | | | | | + | | | | | | | | + | | | | | | |10| + +--|-------------------------------+ | | +------------------------------|--+ + | | | 490 | + +---------------------------------+ +---------------------------------+ + 500 500 + */ +} + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegionWithSurfaceAlreadyOnStack) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> child2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child); + child->addChild(layer); + parent->addChild(child2); + + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(90); + childTransform.translate(-250, -250); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); + setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(10, 10), IntSize(500, 500), true); + + // |child2| makes |parent|'s surface get considered by CCOcclusionTracker first, instead of |child|'s. This exercises different code in + // leaveToTargetRenderSurface, as the target surface has already been seen. + setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(60, 20), true); + + child->setMasksToBounds(true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(parent->renderSurface()); + occlusion.markOccludedBehindLayer(child2.get()); + + EXPECT_EQ_RECT(IntRect(30, 30, 60, 20), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 30, 60, 20), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + occlusion.enterTargetRenderSurface(child->renderSurface()); + occlusion.markOccludedBehindLayer(layer.get()); + + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 430, 60, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child.get(), IntRect(10, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(9, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 429, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(11, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 431, 60, 70))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(child.get(), IntRect(10, 430, 60, 70)).isEmpty()); + // This is the little piece not occluded by child2 + EXPECT_EQ_RECT(IntRect(9, 430, 1, 10), occlusion.unoccludedContentRect(child.get(), IntRect(9, 430, 60, 70))); + // This extends past both sides of child2, so it will be the original rect. + EXPECT_EQ_RECT(IntRect(9, 430, 60, 80), occlusion.unoccludedContentRect(child.get(), IntRect(9, 430, 60, 80))); + // This extends past two adjacent sides of child2, and should included the unoccluded parts of each side. + // This also demonstrates that the rect can be arbitrary and does not get clipped to the layer's visibleLayerRect(). + EXPECT_EQ_RECT(IntRect(-10, 430, 20, 70), occlusion.unoccludedContentRect(child.get(), IntRect(-10, 430, 60, 70))); + // This extends past three adjacent sides of child2, so it should contain the unoccluded parts of each side. The left + // and bottom edges are completely unoccluded for some row/column so we get back the original query rect. + EXPECT_EQ_RECT(IntRect(-10, 430, 60, 80), occlusion.unoccludedContentRect(child.get(), IntRect(-10, 430, 60, 80))); + EXPECT_EQ_RECT(IntRect(10, 429, 60, 1), occlusion.unoccludedContentRect(child.get(), IntRect(10, 429, 60, 70))); + EXPECT_EQ_RECT(IntRect(70, 430, 1, 70), occlusion.unoccludedContentRect(child.get(), IntRect(11, 430, 60, 70))); + EXPECT_EQ_RECT(IntRect(10, 500, 60, 1), occlusion.unoccludedContentRect(child.get(), IntRect(10, 431, 60, 70))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(10, 430, 60, 70), occlusion.surfaceUnoccludedContentRect(child.get(), IntRect(10, 430, 60, 70))); + + occlusion.markOccludedBehindLayer(child.get()); + // |child2| should get merged with the surface we are leaving now + occlusion.finishedTargetRenderSurface(child.get(), child->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInTargetSurface().rects().size()); + + Vector<IntRect> screen = occlusion.occlusionInScreenSpace().rects(); + Vector<IntRect> target = occlusion.occlusionInTargetSurface().rects(); + + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 30, 70, 70))); + EXPECT_EQ_RECT(IntRect(90, 30, 10, 10), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 30, 70, 70))); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 30, 60, 10))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 30, 60, 10))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 29, 60, 10))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(31, 30, 60, 10))); + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 31, 60, 10))); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 40, 70, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 40, 70, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 39, 70, 60))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(30, 30, 60, 10)).isEmpty()); + EXPECT_EQ_RECT(IntRect(29, 30, 1, 10), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 30, 60, 10))); + EXPECT_EQ_RECT(IntRect(30, 29, 60, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 29, 60, 10))); + EXPECT_EQ_RECT(IntRect(90, 30, 1, 10), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 30, 60, 10))); + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(30, 31, 60, 10)).isEmpty()); + + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(30, 40, 70, 60)).isEmpty()); + EXPECT_EQ_RECT(IntRect(29, 40, 1, 60), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 40, 70, 60))); + // This rect is mostly occluded by |child2|. + EXPECT_EQ_RECT(IntRect(90, 39, 10, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 39, 70, 60))); + // This rect extends past top/right ends of |child2|. + EXPECT_EQ_RECT(IntRect(30, 29, 70, 11), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 29, 70, 70))); + // This rect extends past left/right ends of |child2|. + EXPECT_EQ_RECT(IntRect(20, 39, 80, 60), occlusion.unoccludedContentRect(parent.get(), IntRect(20, 39, 80, 60))); + EXPECT_EQ_RECT(IntRect(100, 40, 1, 60), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 40, 70, 60))); + EXPECT_EQ_RECT(IntRect(30, 100, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 41, 70, 60))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.surfaceUnoccludedContentRect(parent.get(), IntRect(30, 40, 70, 60))); + + + /* Justification for the above occlusion from |layer|: + 100 + +---------------------+ +---------------------+ + | | | |30 Visible region of |layer|: ///// + | 30 | rotate(90) | 30 60 | |child2|: \\\\\ + | 30 + ------------+--------------------+ | 30 +------------+--------------------+ + 100 | | 10 | | | ==> | |\\\\\\\\\\\\| |10 | + | |10+----------|----------------------+ | +--|\\\\\\\\\\\\|-----------------+ | + | + ------------+ | | | | | +------------+//| 420 | | + | | | | | | | | |///////////////|60 | | + | | | | | | | | |///////////////| | | + +----|--|-------------+ | | +--|--|---------------+ | | + | | | | 20|10| 70 | | + | | | | | | | | + | | | |500 | | | | + | | | | | | | | + | | | | | | | | + | | | | | | | | + | | | | | | |10| + +--|-------------------------------+ | | +------------------------------|--+ + | | | 490 | + +---------------------------------+ +---------------------------------+ + 500 500 + */ +} + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegionWithRotatedOffAxisSurface) +{ + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child); + child->addChild(layer); + + // Now rotate the child a little more so it is not axis-aligned. The parent will no longer be occluded by |layer|, but + // the child's occlusion should be unchanged. + + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(95); + childTransform.translate(-250, -250); + + TransformationMatrix layerTransform; + layerTransform.translate(10, 10); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); + setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), true); + + child->setMasksToBounds(true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + IntRect clippedLayerInChild = layerTransform.mapRect(layer->visibleLayerRect()); + + occlusion.enterTargetRenderSurface(child->renderSurface()); + occlusion.markOccludedBehindLayer(layer.get()); + + EXPECT_EQ_RECT(IntRect(), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(0u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(clippedLayerInChild, occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child.get(), clippedLayerInChild)); + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), clippedLayerInChild).isEmpty()); + clippedLayerInChild.move(-1, 0); + EXPECT_FALSE(occlusion.occluded(child.get(), clippedLayerInChild)); + EXPECT_FALSE(occlusion.unoccludedContentRect(parent.get(), clippedLayerInChild).isEmpty()); + clippedLayerInChild.move(1, 0); + clippedLayerInChild.move(1, 0); + EXPECT_FALSE(occlusion.occluded(child.get(), clippedLayerInChild)); + EXPECT_FALSE(occlusion.unoccludedContentRect(parent.get(), clippedLayerInChild).isEmpty()); + clippedLayerInChild.move(-1, 0); + clippedLayerInChild.move(0, -1); + EXPECT_FALSE(occlusion.occluded(child.get(), clippedLayerInChild)); + EXPECT_FALSE(occlusion.unoccludedContentRect(parent.get(), clippedLayerInChild).isEmpty()); + clippedLayerInChild.move(0, 1); + clippedLayerInChild.move(0, 1); + EXPECT_FALSE(occlusion.occluded(child.get(), clippedLayerInChild)); + EXPECT_FALSE(occlusion.unoccludedContentRect(parent.get(), clippedLayerInChild).isEmpty()); + clippedLayerInChild.move(0, -1); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(0, 0, 500, 500), occlusion.surfaceUnoccludedContentRect(child.get(), IntRect(0, 0, 500, 500))); + + occlusion.markOccludedBehindLayer(child.get()); + occlusion.finishedTargetRenderSurface(child.get(), child->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(0u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(0u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(75, 55, 1, 1))); + EXPECT_EQ_RECT(IntRect(75, 55, 1, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(75, 55, 1, 1))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(0, 0, 100, 100), occlusion.surfaceUnoccludedContentRect(parent.get(), IntRect(0, 0, 100, 100))); +} + +TEST(CCOcclusionTrackerTest, layerAddedToOccludedRegionWithMultipleOpaqueLayers) +{ + // This is similar to the previous test but now we make a few opaque layers inside of |child| so that the occluded parts of child are not a simple rect. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer1 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> layer2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child); + child->addChild(layer1); + child->addChild(layer2); + + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(90); + childTransform.translate(-250, -250); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); + setLayerPropertiesForTesting(layer1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(10, 10), IntSize(500, 440), true); + setLayerPropertiesForTesting(layer2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(10, 450), IntSize(500, 60), true); + + child->setMasksToBounds(true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(child->renderSurface()); + occlusion.markOccludedBehindLayer(layer2.get()); + occlusion.markOccludedBehindLayer(layer1.get()); + + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 430, 60, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child.get(), IntRect(10, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(9, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 429, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(11, 430, 60, 70))); + EXPECT_FALSE(occlusion.occluded(child.get(), IntRect(10, 431, 60, 70))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(child.get(), IntRect(10, 430, 60, 70)).isEmpty()); + EXPECT_EQ_RECT(IntRect(9, 430, 1, 70), occlusion.unoccludedContentRect(child.get(), IntRect(9, 430, 60, 70))); + EXPECT_EQ_RECT(IntRect(10, 429, 60, 1), occlusion.unoccludedContentRect(child.get(), IntRect(10, 429, 60, 70))); + EXPECT_EQ_RECT(IntRect(70, 430, 1, 70), occlusion.unoccludedContentRect(child.get(), IntRect(11, 430, 60, 70))); + EXPECT_EQ_RECT(IntRect(10, 500, 60, 1), occlusion.unoccludedContentRect(child.get(), IntRect(10, 431, 60, 70))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(10, 430, 60, 70), occlusion.surfaceUnoccludedContentRect(child.get(), IntRect(10, 430, 60, 70))); + + occlusion.markOccludedBehindLayer(child.get()); + occlusion.finishedTargetRenderSurface(child.get(), child->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 40, 70, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 40, 70, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 39, 70, 60))); + + EXPECT_TRUE(occlusion.unoccludedContentRect(parent.get(), IntRect(30, 40, 70, 60)).isEmpty()); + EXPECT_EQ_RECT(IntRect(29, 40, 1, 60), occlusion.unoccludedContentRect(parent.get(), IntRect(29, 40, 70, 60))); + EXPECT_EQ_RECT(IntRect(30, 39, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 39, 70, 60))); + EXPECT_EQ_RECT(IntRect(100, 40, 1, 60), occlusion.unoccludedContentRect(parent.get(), IntRect(31, 40, 70, 60))); + EXPECT_EQ_RECT(IntRect(30, 100, 70, 1), occlusion.unoccludedContentRect(parent.get(), IntRect(30, 41, 70, 60))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(30, 40, 70, 60), occlusion.surfaceUnoccludedContentRect(parent.get(), IntRect(30, 40, 70, 60))); + + + /* Justification for the above occlusion from |layer1| and |layer2|: + + +---------------------+ + | |30 Visible region of |layer1|: ///// + | | Visible region of |layer2|: \\\\\ + | +---------------------------------+ + | | |10 | + | +---------------+-----------------+ | + | | |\\\\\\\\\\\\|//| 420 | | + | | |\\\\\\\\\\\\|//|60 | | + | | |\\\\\\\\\\\\|//| | | + +--|--|------------|--+ | | + 20|10| 70 | | | + | | | | | + | | | | | + | | | | | + | | | | | + | | | | | + | | | |10| + | +------------|-----------------|--+ + | | 490 | + +---------------+-----------------+ + 60 440 + */ +} + +TEST(CCOcclusionTrackerTest, surfaceOcclusionWithOverlappingSiblingSurfaces) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child1 = LayerChromium::create(); + RefPtr<LayerChromium> child2 = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer1 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> layer2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child1); + parent->addChild(child2); + child1->addChild(layer1); + child2->addChild(layer2); + + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(90); + childTransform.translate(-250, -250); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child1.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), false); + setLayerPropertiesForTesting(layer1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), true); + setLayerPropertiesForTesting(child2.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(20, 40), IntSize(500, 500), false); + setLayerPropertiesForTesting(layer2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), true); + + child1->setMasksToBounds(true); + child2->setMasksToBounds(true); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(child2->renderSurface()); + occlusion.markOccludedBehindLayer(layer2.get()); + + EXPECT_EQ_RECT(IntRect(20, 40, 80, 60), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(0, 420, 60, 80), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child2.get(), IntRect(0, 420, 60, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-1, 420, 60, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(0, 419, 60, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(0, 420, 61, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(0, 420, 60, 81))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(0, 420, 60, 80), occlusion.surfaceUnoccludedContentRect(child2.get(), IntRect(0, 420, 60, 80))); + + occlusion.markOccludedBehindLayer(child2.get()); + occlusion.finishedTargetRenderSurface(child2.get(), child2->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + occlusion.enterTargetRenderSurface(child1->renderSurface()); + occlusion.markOccludedBehindLayer(layer1.get()); + + EXPECT_EQ_RECT(IntRect(20, 30, 80, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(0, 430, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child1.get(), IntRect(0, 430, 70, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(-1, 430, 70, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(0, 429, 70, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(0, 430, 71, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(0, 430, 70, 71))); + + // Surface is not occluded by things that draw into itself, but the |child1| surface should be occluded by the |child2| surface. + EXPECT_EQ_RECT(IntRect(0, 430, 10, 70), occlusion.surfaceUnoccludedContentRect(child1.get(), IntRect(0, 430, 70, 70))); + + occlusion.markOccludedBehindLayer(child1.get()); + occlusion.finishedTargetRenderSurface(child1.get(), child1->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(20, 30, 80, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(20, 30, 80, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(20, 30, 80, 70))); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 30, 70, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 29, 70, 70))); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(20, 40, 80, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(19, 40, 80, 60))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(20, 39, 80, 60))); + + // |child1| and |child2| both draw into parent so they should not occlude it. + EXPECT_EQ_RECT(IntRect(20, 30, 80, 70), occlusion.surfaceUnoccludedContentRect(parent.get(), IntRect(20, 30, 80, 70))); + + + /* Justification for the above occlusion: + 100 + +---------------------+ + | | + | 30 | child1 + | 30+ ---------------------------------+ + 100 | 40| | child2 | + |20+----------------------------------+ | + | | | | | | + | | | | | | + | | | | | | + +--|-|----------------+ | | + | | | | 500 + | | | | + | | | | + | | | | + | | | | + | | | | + | | | | + | +--------------------------------|-+ + | | + +----------------------------------+ + 500 + */ +} + +TEST(CCOcclusionTrackerTest, surfaceOcclusionInScreenSpace) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child1 = LayerChromium::create(); + RefPtr<LayerChromium> child2 = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer1 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> layer2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child1); + parent->addChild(child2); + child1->addChild(layer1); + child2->addChild(layer2); + + TransformationMatrix childTransform; + childTransform.translate(250, 250); + childTransform.rotate(90); + childTransform.translate(-250, -250); + + // The owning layers have very different bounds from the surfaces that they own. + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child1.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(10, 10), false); + setLayerPropertiesForTesting(layer1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(-10, -10), IntSize(510, 510), true); + setLayerPropertiesForTesting(child2.get(), childTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(20, 40), IntSize(10, 10), false); + setLayerPropertiesForTesting(layer2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(-10, -10), IntSize(510, 510), true); + + // Make them both render surfaces + FilterOperations filters; + filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE)); + child1->setFilters(filters); + child2->setFilters(filters); + + child1->setMasksToBounds(false); + child2->setMasksToBounds(false); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(child2->renderSurface()); + occlusion.markOccludedBehindLayer(layer2.get()); + + EXPECT_EQ_RECT(IntRect(20, 30, 80, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(-10, 420, 70, 80), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child2.get(), IntRect(-10, 420, 70, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-11, 420, 70, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-10, 419, 70, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-10, 420, 71, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-10, 420, 70, 81))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(-10, 420, 70, 80), occlusion.surfaceUnoccludedContentRect(child2.get(), IntRect(-10, 420, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child2.get(), IntRect(30, 250, 1, 1))); + + occlusion.markOccludedBehindLayer(child2.get()); + occlusion.finishedTargetRenderSurface(child2.get(), child2->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + occlusion.enterTargetRenderSurface(child1->renderSurface()); + occlusion.markOccludedBehindLayer(layer1.get()); + + EXPECT_EQ_RECT(IntRect(20, 20, 80, 80), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(-10, 430, 80, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child1.get(), IntRect(-10, 430, 80, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(-11, 430, 80, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(-10, 429, 80, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(-10, 430, 81, 70))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(-10, 430, 80, 71))); + + // Surface is not occluded by things that draw into itself, but the |child1| surface should be occluded by the |child2| surface. + EXPECT_EQ_RECT(IntRect(-10, 430, 10, 80), occlusion.surfaceUnoccludedContentRect(child1.get(), IntRect(-10, 430, 70, 80))); + EXPECT_TRUE(occlusion.surfaceOccluded(child1.get(), IntRect(0, 430, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(-1, 430, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(0, 429, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(1, 430, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(0, 431, 70, 80))); + + occlusion.markOccludedBehindLayer(child1.get()); + occlusion.finishedTargetRenderSurface(child1.get(), child1->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(20, 20, 80, 80), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(20, 20, 80, 80), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(2u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(20, 20, 80, 80))); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(30, 20, 70, 80))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(29, 20, 70, 80))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(30, 19, 70, 80))); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(20, 30, 80, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(19, 30, 80, 70))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(20, 29, 80, 70))); + + // |child1| and |child2| both draw into parent so they should not occlude it. + EXPECT_EQ_RECT(IntRect(20, 20, 80, 80), occlusion.surfaceUnoccludedContentRect(parent.get(), IntRect(20, 20, 80, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(parent.get(), IntRect(50, 50, 1, 1))); + + + /* Justification for the above occlusion: + 100 + +---------------------+ + | 20 | layer1 + | 30+ ---------------------------------+ + 100 | 30| | layer2 | + |20+----------------------------------+ | + | | | | | | + | | | | | | + | | | | | | + +--|-|----------------+ | | + | | | | 510 + | | | | + | | | | + | | | | + | | | | + | | | | + | | | | + | +--------------------------------|-+ + | | + +----------------------------------+ + 510 + */ +} + +TEST(CCOcclusionTrackerTest, surfaceOcclusionInScreenSpaceDifferentTransforms) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child1 = LayerChromium::create(); + RefPtr<LayerChromium> child2 = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> layer1 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> layer2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(child1); + parent->addChild(child2); + child1->addChild(layer1); + child2->addChild(layer2); + + TransformationMatrix child1Transform; + child1Transform.translate(250, 250); + child1Transform.rotate(-90); + child1Transform.translate(-250, -250); + + TransformationMatrix child2Transform; + child2Transform.translate(250, 250); + child2Transform.rotate(90); + child2Transform.translate(-250, -250); + + // The owning layers have very different bounds from the surfaces that they own. + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child1.get(), child1Transform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 20), IntSize(10, 10), false); + setLayerPropertiesForTesting(layer1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(-10, -20), IntSize(510, 520), true); + setLayerPropertiesForTesting(child2.get(), child2Transform, identityMatrix, FloatPoint(0, 0), FloatPoint(20, 40), IntSize(10, 10), false); + setLayerPropertiesForTesting(layer2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(-10, -10), IntSize(510, 510), true); + + // Make them both render surfaces + FilterOperations filters; + filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE)); + child1->setFilters(filters); + child2->setFilters(filters); + + child1->setMasksToBounds(false); + child2->setMasksToBounds(false); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + occlusion.enterTargetRenderSurface(child2->renderSurface()); + occlusion.markOccludedBehindLayer(layer2.get()); + + EXPECT_EQ_RECT(IntRect(20, 30, 80, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(-10, 420, 70, 80), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child2.get(), IntRect(-10, 420, 70, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-11, 420, 70, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-10, 419, 70, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-10, 420, 71, 80))); + EXPECT_FALSE(occlusion.occluded(child2.get(), IntRect(-10, 420, 70, 81))); + + // Surface is not occluded by things that draw into itself. + EXPECT_EQ_RECT(IntRect(-10, 420, 70, 80), occlusion.surfaceUnoccludedContentRect(child2.get(), IntRect(-10, 420, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child2.get(), IntRect(30, 250, 1, 1))); + + occlusion.markOccludedBehindLayer(child2.get()); + occlusion.finishedTargetRenderSurface(child2.get(), child2->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + occlusion.enterTargetRenderSurface(child1->renderSurface()); + occlusion.markOccludedBehindLayer(layer1.get()); + + EXPECT_EQ_RECT(IntRect(10, 20, 90, 80), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(420, -20, 80, 90), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(child1.get(), IntRect(420, -20, 80, 90))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(419, -20, 80, 90))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(420, -21, 80, 90))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(420, -19, 80, 90))); + EXPECT_FALSE(occlusion.occluded(child1.get(), IntRect(421, -20, 80, 90))); + + // Surface is not occluded by things that draw into itself, but the |child1| surface should be occluded by the |child2| surface. + EXPECT_EQ_RECT(IntRect(420, -20, 80, 90), occlusion.surfaceUnoccludedContentRect(child1.get(), IntRect(420, -20, 80, 90))); + EXPECT_EQ_RECT(IntRect(490, -10, 10, 80), occlusion.surfaceUnoccludedContentRect(child1.get(), IntRect(420, -10, 80, 80))); + EXPECT_EQ_RECT(IntRect(420, -20, 70, 10), occlusion.surfaceUnoccludedContentRect(child1.get(), IntRect(420, -20, 70, 90))); + EXPECT_TRUE(occlusion.surfaceOccluded(child1.get(), IntRect(420, -10, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(419, -10, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(420, -11, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(421, -10, 70, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(child1.get(), IntRect(420, -9, 70, 80))); + + occlusion.markOccludedBehindLayer(child1.get()); + occlusion.finishedTargetRenderSurface(child1.get(), child1->renderSurface()); + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + + EXPECT_EQ_RECT(IntRect(10, 20, 90, 80), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(10, 20, 90, 80), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + EXPECT_TRUE(occlusion.occluded(parent.get(), IntRect(10, 20, 90, 80))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(9, 20, 90, 80))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(10, 19, 90, 80))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(11, 20, 90, 80))); + EXPECT_FALSE(occlusion.occluded(parent.get(), IntRect(10, 21, 90, 80))); + + // |child1| and |child2| both draw into parent so they should not occlude it. + EXPECT_EQ_RECT(IntRect(10, 20, 90, 80), occlusion.surfaceUnoccludedContentRect(parent.get(), IntRect(10, 20, 90, 80))); + EXPECT_FALSE(occlusion.surfaceOccluded(parent.get(), IntRect(10, 20, 1, 1))); + EXPECT_FALSE(occlusion.surfaceOccluded(parent.get(), IntRect(99, 20, 1, 1))); + EXPECT_FALSE(occlusion.surfaceOccluded(parent.get(), IntRect(10, 9, 1, 1))); + EXPECT_FALSE(occlusion.surfaceOccluded(parent.get(), IntRect(99, 99, 1, 1))); + + + /* Justification for the above occlusion: + 100 + +---------------------+ + |20 | layer1 + 10+----------------------------------+ + 100 || 30 | layer2 | + |20+----------------------------------+ + || | | | | + || | | | | + || | | | | + +|-|------------------+ | | + | | | | 510 + | | 510 | | + | | | | + | | | | + | | | | + | | | | + | | 520 | | + +----------------------------------+ | + | | + +----------------------------------+ + 510 + */ +} + +TEST(CCOcclusionTrackerTest, occlusionInteractionWithFilters) +{ + // This tests that the right transforms are being used. + TestCCOcclusionTracker occlusion; + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> blurLayer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> opacityLayer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> opaqueLayer = adoptRef(new LayerChromiumWithForcedDrawsContent()); + parent->createRenderSurface(); + parent->addChild(blurLayer); + parent->addChild(opacityLayer); + parent->addChild(opaqueLayer); + + TransformationMatrix layerTransform; + layerTransform.translate(250, 250); + layerTransform.rotate(90); + layerTransform.translate(-250, -250); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(blurLayer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + setLayerPropertiesForTesting(opaqueLayer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + setLayerPropertiesForTesting(opacityLayer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(30, 30), IntSize(500, 500), true); + + { + FilterOperations filters; + filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Percent), FilterOperation::BLUR)); + blurLayer->setFilters(filters); + } + + { + FilterOperations filters; + filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE)); + opaqueLayer->setFilters(filters); + } + + { + FilterOperations filters; + filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY)); + opacityLayer->setFilters(filters); + } + + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->renderSurface()->setContentRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + // Opacity layer won't contribute to occlusion. + occlusion.enterTargetRenderSurface(opacityLayer->renderSurface()); + occlusion.markOccludedBehindLayer(opacityLayer.get()); + occlusion.finishedTargetRenderSurface(opacityLayer.get(), opacityLayer->renderSurface()); + + EXPECT_TRUE(occlusion.occlusionInScreenSpace().isEmpty()); + EXPECT_TRUE(occlusion.occlusionInTargetSurface().isEmpty()); + + // And has nothing to contribute to its parent surface. + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + EXPECT_TRUE(occlusion.occlusionInScreenSpace().isEmpty()); + EXPECT_TRUE(occlusion.occlusionInTargetSurface().isEmpty()); + + // Opaque layer will contribute to occlusion. + occlusion.enterTargetRenderSurface(opaqueLayer->renderSurface()); + occlusion.markOccludedBehindLayer(opaqueLayer.get()); + occlusion.finishedTargetRenderSurface(opaqueLayer.get(), opaqueLayer->renderSurface()); + + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(0, 430, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + // And it gets translated to the parent surface. + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); + + // The blur layer needs to throw away any occlusion from outside its subtree. + occlusion.enterTargetRenderSurface(blurLayer->renderSurface()); + EXPECT_TRUE(occlusion.occlusionInScreenSpace().isEmpty()); + EXPECT_TRUE(occlusion.occlusionInTargetSurface().isEmpty()); + + // And it won't contribute to occlusion. + occlusion.markOccludedBehindLayer(blurLayer.get()); + occlusion.finishedTargetRenderSurface(blurLayer.get(), blurLayer->renderSurface()); + EXPECT_TRUE(occlusion.occlusionInScreenSpace().isEmpty()); + EXPECT_TRUE(occlusion.occlusionInTargetSurface().isEmpty()); + + // But the opaque layer's occlusion is preserved on the parent. + occlusion.leaveToTargetRenderSurface(parent->renderSurface()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInScreenSpace().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size()); + EXPECT_EQ_RECT(IntRect(30, 30, 70, 70), occlusion.occlusionInTargetSurface().bounds()); + EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size()); +} + +} // namespace diff --git a/Source/WebKit/chromium/tests/CCQuadCullerTest.cpp b/Source/WebKit/chromium/tests/CCQuadCullerTest.cpp index 299e5c7e5..d49703e14 100644 --- a/Source/WebKit/chromium/tests/CCQuadCullerTest.cpp +++ b/Source/WebKit/chromium/tests/CCQuadCullerTest.cpp @@ -79,7 +79,7 @@ TEST(CCQuadCullerTest, verifyCullChildLinesUpTopLeft) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 9u); } @@ -92,7 +92,7 @@ TEST(CCQuadCullerTest, verifyCullWhenChildOpacityNotOne) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 13u); } @@ -105,7 +105,7 @@ TEST(CCQuadCullerTest, verifyCullWhenChildOpaqueFlagFalse) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 13u); } @@ -120,7 +120,7 @@ TEST(CCQuadCullerTest, verifyCullCenterTileOnly) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 12u); IntRect quadVisibleRect1 = quadList[1].get()->quadVisibleRect(); @@ -158,7 +158,7 @@ TEST(CCQuadCullerTest, verifyCullCenterTileNonIntegralSize1) quadList.append(MakeTileQuad(childState.get(), IntRect(IntPoint(), IntSize(100, 100)))); EXPECT_EQ(quadList.size(), 2u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 2u); } @@ -181,7 +181,7 @@ TEST(CCQuadCullerTest, verifyCullCenterTileNonIntegralSize2) quadList.append(MakeTileQuad(childState.get(), IntRect(IntPoint(), IntSize(100, 100)))); EXPECT_EQ(quadList.size(), 2u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 2u); } @@ -196,7 +196,7 @@ TEST(CCQuadCullerTest, verifyCullChildLinesUpBottomRight) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 9u); } @@ -212,7 +212,7 @@ TEST(CCQuadCullerTest, verifyCullSubRegion) setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 12u); } @@ -228,7 +228,7 @@ TEST(CCQuadCullerTest, verifyCullSubRegion2) setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 12u); } @@ -244,7 +244,7 @@ TEST(CCQuadCullerTest, verifyCullSubRegionCheckOvercull) setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 13u); } @@ -260,7 +260,7 @@ TEST(CCQuadCullerTest, verifyNonAxisAlignedQuadsDontOcclude) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 13u); } @@ -282,8 +282,61 @@ TEST(CCQuadCullerTest, verifyNonAxisAlignedQuadsSafelyCulled) setQuads(rootState.get(), childState.get(), quadList); EXPECT_EQ(quadList.size(), 13u); - CCQuadCuller::cullOccludedQuads(quadList); + CCQuadCuller::cullOccludedQuads(quadList, false, IntRect()); EXPECT_EQ(quadList.size(), 12u); } +TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverTile) +{ + DECLARE_AND_INITIALIZE_TEST_QUADS + + OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true); + OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true); + + setQuads(rootState.get(), childState.get(), quadList); + EXPECT_EQ(quadList.size(), 13u); + CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(200, 100, 100, 100)); + EXPECT_EQ(quadList.size(), 1u); +} + +TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverCulledTile) +{ + DECLARE_AND_INITIALIZE_TEST_QUADS + + OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true); + OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true); + + setQuads(rootState.get(), childState.get(), quadList); + EXPECT_EQ(quadList.size(), 13u); + CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(100, 100, 100, 100)); + EXPECT_EQ(quadList.size(), 1u); +} + +TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverPartialTiles) +{ + DECLARE_AND_INITIALIZE_TEST_QUADS + + OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true); + OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true); + + setQuads(rootState.get(), childState.get(), quadList); + EXPECT_EQ(quadList.size(), 13u); + CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(50, 50, 200, 200)); + EXPECT_EQ(quadList.size(), 9u); +} + +TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverNoTiles) +{ + DECLARE_AND_INITIALIZE_TEST_QUADS + + OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true); + OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true); + + setQuads(rootState.get(), childState.get(), quadList); + EXPECT_EQ(quadList.size(), 13u); + CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(500, 500, 100, 100)); + EXPECT_EQ(quadList.size(), 0u); +} + + } // namespace diff --git a/Source/WebKit/chromium/tests/Canvas2DLayerChromiumTest.cpp b/Source/WebKit/chromium/tests/Canvas2DLayerChromiumTest.cpp index 4b3dd27d3..ec0ce0c6a 100644 --- a/Source/WebKit/chromium/tests/Canvas2DLayerChromiumTest.cpp +++ b/Source/WebKit/chromium/tests/Canvas2DLayerChromiumTest.cpp @@ -79,8 +79,8 @@ protected: { GraphicsContext3D::Attributes attrs; - RefPtr<GraphicsContext3D> mainContext = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new MockCanvasContext()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); - RefPtr<GraphicsContext3D> implContext = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new MockCanvasContext()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> mainContext = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new MockCanvasContext()), GraphicsContext3D::RenderDirectlyToHostWindow); + RefPtr<GraphicsContext3D> implContext = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new MockCanvasContext()), GraphicsContext3D::RenderDirectlyToHostWindow); MockCanvasContext& mainMock = *static_cast<MockCanvasContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(mainContext.get())); MockCanvasContext& implMock = *static_cast<MockCanvasContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(implContext.get())); diff --git a/Source/WebKit/chromium/tests/CompositorFakeGraphicsContext3D.h b/Source/WebKit/chromium/tests/CompositorFakeGraphicsContext3D.h index 1f0897341..937b62d4c 100644 --- a/Source/WebKit/chromium/tests/CompositorFakeGraphicsContext3D.h +++ b/Source/WebKit/chromium/tests/CompositorFakeGraphicsContext3D.h @@ -37,10 +37,7 @@ static PassRefPtr<GraphicsContext3D> createCompositorMockGraphicsContext3D(Graph webAttrs.alpha = attrs.alpha; OwnPtr<WebKit::WebGraphicsContext3D> webContext = WebKit::CompositorFakeWebGraphicsContext3D::create(webAttrs); - return GraphicsContext3DPrivate::createGraphicsContextFromWebContext( - webContext.release(), attrs, 0, - GraphicsContext3D::RenderDirectlyToHostWindow, - GraphicsContext3DPrivate::ForUseOnAnotherThread); + return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), GraphicsContext3D::RenderDirectlyToHostWindow); } } diff --git a/Source/WebKit/chromium/tests/FakeGraphicsContext3DTest.cpp b/Source/WebKit/chromium/tests/FakeGraphicsContext3DTest.cpp index 2b76b80ad..71cb8bab1 100644 --- a/Source/WebKit/chromium/tests/FakeGraphicsContext3DTest.cpp +++ b/Source/WebKit/chromium/tests/FakeGraphicsContext3DTest.cpp @@ -52,7 +52,7 @@ private: TEST(FakeGraphicsContext3DTest, CanOverrideManually) { GraphicsContext3D::Attributes attrs; - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new FrameCountingContext()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new FrameCountingContext()), GraphicsContext3D::RenderDirectlyToHostWindow); FrameCountingContext& mockContext = *static_cast<FrameCountingContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get())); for (int i = 0; i < 10; i++) { @@ -73,7 +73,7 @@ public: TEST(FakeGraphicsContext3DTest, CanUseGMock) { GraphicsContext3D::Attributes attrs; - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new GMockContext()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new GMockContext()), GraphicsContext3D::RenderDirectlyToHostWindow); GMockContext& mockContext = *static_cast<GMockContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get())); EXPECT_CALL(mockContext, getError()) @@ -104,7 +104,7 @@ private: TEST(FakeGraphicsContext3DTest, ContextForThisThreadShouldNotMakeCurrent) { GraphicsContext3D::Attributes attrs; - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new ContextThatCountsMakeCurrents()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnThisThread); + RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new ContextThatCountsMakeCurrents()), GraphicsContext3D::RenderDirectlyToHostWindow); EXPECT_TRUE(context); ContextThatCountsMakeCurrents& mockContext = *static_cast<ContextThatCountsMakeCurrents*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get())); EXPECT_EQ(0, mockContext.makeCurrentCount()); @@ -113,7 +113,7 @@ TEST(FakeGraphicsContext3DTest, ContextForThisThreadShouldNotMakeCurrent) TEST(FakeGraphicsContext3DTest, ContextForAnotherThreadShouldNotMakeCurrent) { GraphicsContext3D::Attributes attrs; - RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new ContextThatCountsMakeCurrents()), attrs, 0, GraphicsContext3D::RenderDirectlyToHostWindow, GraphicsContext3DPrivate::ForUseOnAnotherThread); + RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new ContextThatCountsMakeCurrents()), GraphicsContext3D::RenderDirectlyToHostWindow); EXPECT_TRUE(context); ContextThatCountsMakeCurrents& mockContext = *static_cast<ContextThatCountsMakeCurrents*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get())); EXPECT_EQ(0, mockContext.makeCurrentCount()); diff --git a/Source/WebKit/chromium/tests/FakeWebGraphicsContext3D.h b/Source/WebKit/chromium/tests/FakeWebGraphicsContext3D.h index cf0651b77..ae27da730 100644 --- a/Source/WebKit/chromium/tests/FakeWebGraphicsContext3D.h +++ b/Source/WebKit/chromium/tests/FakeWebGraphicsContext3D.h @@ -65,6 +65,8 @@ public: virtual void setVisibilityCHROMIUM(bool visible) { } + virtual void setMemoryAllocationChangedCallbackCHROMIUM(WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback) { } + virtual WebString getRequestableExtensionsCHROMIUM() { return WebString(); } virtual void requestExtensionCHROMIUM(const char*) { } diff --git a/Source/WebKit/chromium/tests/LayerChromiumTest.cpp b/Source/WebKit/chromium/tests/LayerChromiumTest.cpp index 43083a1d7..2e9ca9661 100644 --- a/Source/WebKit/chromium/tests/LayerChromiumTest.cpp +++ b/Source/WebKit/chromium/tests/LayerChromiumTest.cpp @@ -515,6 +515,7 @@ TEST_F(LayerChromiumTest, checkPropertyChangeCausesCorrectBehavior) EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setReplicaLayer(dummyLayer.get())); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setSublayerTransform(TransformationMatrix(0, 0, 0, 0, 0, 0))); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollable(true)); + EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setHaveWheelEventHandlers(true)); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollPosition(IntPoint(10, 10))); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setTransform(TransformationMatrix(0, 0, 0, 0, 0, 0))); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDoubleSided(false)); @@ -539,10 +540,21 @@ public: return true; } + virtual void setNeedsDisplayRect(const FloatRect& dirtyRect) + { + m_lastNeedsDisplayRect = dirtyRect; + LayerChromium::setNeedsDisplayRect(dirtyRect); + } + void resetNeedsDisplay() { m_needsDisplay = false; } + + const FloatRect& lastNeedsDisplayRect() const { return m_lastNeedsDisplayRect; } + +private: + FloatRect m_lastNeedsDisplayRect; }; TEST_F(LayerChromiumTest, checkContentsScaleChangeTriggersNeedsDisplay) @@ -558,6 +570,7 @@ TEST_F(LayerChromiumTest, checkContentsScaleChangeTriggersNeedsDisplay) EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setContentsScale(testLayer->contentsScale() + 1.f)); EXPECT_TRUE(testLayer->needsDisplay()); + EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 320, 240), testLayer->lastNeedsDisplayRect()); } class FakeCCLayerTreeHost : public CCLayerTreeHost { diff --git a/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp b/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp index 924b42d28..d097c499a 100644 --- a/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp +++ b/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp @@ -163,6 +163,30 @@ TEST(PlatformContextSkiaTest, trackOpaqueClipTest) context.clearRect(FloatRect(10, 10, 90, 90)); EXPECT_EQ_RECT(IntRect(), platformContext.opaqueRegion().asRect()); + // The transform and the clip need to interact correctly (transform first) + context.save(); + context.translate(10, 10); + context.clip(FloatRect(20, 20, 10, 10)); + context.fillRect(FloatRect(10, 10, 90, 90), opaque, ColorSpaceDeviceRGB, CompositeSourceOver); + EXPECT_EQ_RECT(IntRect(30, 30, 10, 10), platformContext.opaqueRegion().asRect()); + EXPECT_PIXELS_MATCH(bitmap, platformContext.opaqueRegion().asRect()); + context.restore(); + + context.clearRect(FloatRect(10, 10, 90, 90)); + EXPECT_EQ_RECT(IntRect(), platformContext.opaqueRegion().asRect()); + + // The transform and the clip need to interact correctly (clip first) + context.save(); + context.clip(FloatRect(20, 20, 10, 10)); + context.translate(10, 10); + context.fillRect(FloatRect(10, 10, 90, 90), opaque, ColorSpaceDeviceRGB, CompositeSourceOver); + EXPECT_EQ_RECT(IntRect(20, 20, 10, 10), platformContext.opaqueRegion().asRect()); + EXPECT_PIXELS_MATCH(bitmap, platformContext.opaqueRegion().asRect()); + context.restore(); + + context.clearRect(FloatRect(10, 10, 90, 90)); + EXPECT_EQ_RECT(IntRect(), platformContext.opaqueRegion().asRect()); + Path path; path.moveTo(FloatPoint(0, 0)); path.addLineTo(FloatPoint(100, 0)); diff --git a/Source/WebKit/chromium/tests/TiledLayerChromiumTest.cpp b/Source/WebKit/chromium/tests/TiledLayerChromiumTest.cpp index fcd3878a6..e03559046 100644 --- a/Source/WebKit/chromium/tests/TiledLayerChromiumTest.cpp +++ b/Source/WebKit/chromium/tests/TiledLayerChromiumTest.cpp @@ -162,6 +162,14 @@ public: return TiledLayerChromium::skipsDraw(); } + virtual void setNeedsDisplayRect(const FloatRect& rect) + { + m_lastNeedsDisplayRect = rect; + TiledLayerChromium::setNeedsDisplayRect(rect); + } + + const FloatRect& lastNeedsDisplayRect() const { return m_lastNeedsDisplayRect; } + FakeLayerTextureUpdater* fakeLayerTextureUpdater() { return m_fakeTextureUpdater.get(); } virtual TextureManager* textureManager() const { return m_textureManager; } @@ -181,6 +189,7 @@ private: RefPtr<FakeLayerTextureUpdater> m_fakeTextureUpdater; TextureManager* m_textureManager; + FloatRect m_lastNeedsDisplayRect; }; class FakeTiledLayerWithScaledBounds : public FakeTiledLayerChromium { @@ -434,6 +443,57 @@ TEST(TiledLayerChromiumTest, verifyUpdateRectWhenContentBoundsAreScaled) EXPECT_FLOAT_RECT_EQ(FloatRect(45, 80, 15, 8), layer->updateRect()); } +TEST(TiledLayerChromiumTest, verifyInvalidationWhenContentsScaleChanges) +{ + OwnPtr<TextureManager> textureManager = TextureManager::create(4*1024*1024, 2*1024*1024, 1024); + RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get())); + DebugScopedSetImplThread implThread; + RefPtr<FakeCCTiledLayerImpl> layerImpl = adoptRef(new FakeCCTiledLayerImpl(0)); + + FakeTextureAllocator textureAllocator; + CCTextureUpdater updater(&textureAllocator); + + // Create a layer with one tile. + layer->setBounds(IntSize(100, 100)); + + // Invalidate the entire layer. + layer->setNeedsDisplay(); + EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 100, 100), layer->lastNeedsDisplayRect()); + + // Push the tiles to the impl side and check that there is exactly one. + layer->prepareToUpdate(IntRect(0, 0, 100, 100)); + layer->updateCompositorResources(0, updater); + layer->pushPropertiesTo(layerImpl.get()); + EXPECT_TRUE(layerImpl->hasTileAt(0, 0)); + EXPECT_FALSE(layerImpl->hasTileAt(0, 1)); + EXPECT_FALSE(layerImpl->hasTileAt(1, 0)); + EXPECT_FALSE(layerImpl->hasTileAt(1, 1)); + + // Change the contents scale and verify that the content rectangle requiring painting + // is not scaled. + layer->setContentsScale(2); + EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 100, 100), layer->lastNeedsDisplayRect()); + + // The impl side should get 2x2 tiles now. + layer->prepareToUpdate(IntRect(0, 0, 200, 200)); + layer->updateCompositorResources(0, updater); + layer->pushPropertiesTo(layerImpl.get()); + EXPECT_TRUE(layerImpl->hasTileAt(0, 0)); + EXPECT_TRUE(layerImpl->hasTileAt(0, 1)); + EXPECT_TRUE(layerImpl->hasTileAt(1, 0)); + EXPECT_TRUE(layerImpl->hasTileAt(1, 1)); + + // Invalidate the entire layer again, but do not paint. All tiles should be gone now from the + // impl side. + layer->setNeedsDisplay(); + layer->updateCompositorResources(0, updater); + layer->pushPropertiesTo(layerImpl.get()); + EXPECT_FALSE(layerImpl->hasTileAt(0, 0)); + EXPECT_FALSE(layerImpl->hasTileAt(0, 1)); + EXPECT_FALSE(layerImpl->hasTileAt(1, 0)); + EXPECT_FALSE(layerImpl->hasTileAt(1, 1)); +} + TEST(TiledLayerChromiumTest, skipsDrawGetsReset) { // Initialize without threading support. @@ -524,7 +584,7 @@ TEST(TiledLayerChromiumTest, layerAddsSelfToOccludedRegion) occluded = Region(); layer->addSelfToOccludedScreenSpace(occluded); EXPECT_EQ_RECT(IntRect(), occluded.bounds()); - EXPECT_EQ(1u, occluded.rects().size()); + EXPECT_EQ(0u, occluded.rects().size()); // If the layer paints opaque content, then the occluded region should match the visible opaque content. IntRect opaquePaintRect = IntRect(10, 10, 90, 190); @@ -546,6 +606,28 @@ TEST(TiledLayerChromiumTest, layerAddsSelfToOccludedRegion) EXPECT_EQ_RECT(intersection(opaquePaintRect, visibleBounds), occluded.bounds()); EXPECT_EQ(1u, occluded.rects().size()); + // If we repaint a non-opaque part of the tile, then it shouldn't lose its opaque-ness. And other tiles should + // not be affected. + layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect()); + layer->invalidateRect(IntRect(0, 0, 1, 1)); + layer->prepareToUpdate(contentBounds); + + occluded = Region(); + layer->addSelfToOccludedScreenSpace(occluded); + EXPECT_EQ_RECT(intersection(opaquePaintRect, visibleBounds), occluded.bounds()); + EXPECT_EQ(1u, occluded.rects().size()); + + // If we repaint an opaque part of the tile, then it should lose its opaque-ness. But other tiles should still + // not be affected. + layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect()); + layer->invalidateRect(IntRect(10, 10, 1, 1)); + layer->prepareToUpdate(contentBounds); + + occluded = Region(); + layer->addSelfToOccludedScreenSpace(occluded); + EXPECT_EQ_RECT(intersection(IntRect(10, 100, 90, 100), visibleBounds), occluded.bounds()); + EXPECT_EQ(1u, occluded.rects().size()); + // If the layer is transformed then the resulting occluded area needs to be transformed to its target space. TransformationMatrix transform; transform.translate(contentBounds.width() / 2.0, contentBounds.height() / 2.0); @@ -556,6 +638,8 @@ TEST(TiledLayerChromiumTest, layerAddsSelfToOccludedRegion) screenSpaceTransform *= transform; screenSpaceTransform.translate(-contentBounds.width() / 2.0, -contentBounds.height() / 2.0); layer->setScreenSpaceTransform(screenSpaceTransform); + layer->fakeLayerTextureUpdater()->setOpaquePaintRect(opaquePaintRect); + layer->invalidateRect(opaquePaintRect); layer->prepareToUpdate(contentBounds); occluded = Region(); diff --git a/Source/WebKit/chromium/tests/TreeSynchronizerTest.cpp b/Source/WebKit/chromium/tests/TreeSynchronizerTest.cpp index 1557a7d93..4724b4a43 100644 --- a/Source/WebKit/chromium/tests/TreeSynchronizerTest.cpp +++ b/Source/WebKit/chromium/tests/TreeSynchronizerTest.cpp @@ -26,13 +26,16 @@ #include "TreeSynchronizer.h" +#include "CCAnimationTestCommon.h" #include "LayerChromium.h" +#include "cc/CCLayerAnimationController.h" #include "cc/CCLayerImpl.h" #include "cc/CCProxy.h" #include "cc/CCSingleThreadProxy.h" #include <gtest/gtest.h> using namespace WebCore; +using namespace WebKitTests; namespace { @@ -91,6 +94,30 @@ private: Vector<int>* m_ccLayerDestructionList; }; +class FakeLayerAnimationController : public CCLayerAnimationController { +public: + static PassOwnPtr<FakeLayerAnimationController> create() + { + return adoptPtr(new FakeLayerAnimationController); + } + + bool synchronizedAnimations() const { return m_synchronizedAnimations; } + +private: + FakeLayerAnimationController() + : m_synchronizedAnimations(false) + { + } + + virtual void synchronizeAnimations(CCLayerAnimationControllerImpl* controllerImpl) + { + CCLayerAnimationController::synchronizeAnimations(controllerImpl); + m_synchronizedAnimations = true; + } + + bool m_synchronizedAnimations; +}; + void expectTreesAreIdentical(LayerChromium* layer, CCLayerImpl* ccLayer) { ASSERT_TRUE(layer); @@ -307,5 +334,19 @@ TEST(TreeSynchronizerTest, syncMaskReplicaAndReplicaMaskLayers) expectTreesAreIdentical(layerTreeRoot.get(), ccLayerTreeRoot.get()); } +TEST(TreeSynchronizerTest, synchronizeAnimations) +{ + DebugScopedSetImplThread impl; + RefPtr<LayerChromium> layerTreeRoot = LayerChromium::create(); + + layerTreeRoot->setLayerAnimationController(FakeLayerAnimationController::create()); + + EXPECT_FALSE(static_cast<FakeLayerAnimationController*>(layerTreeRoot->layerAnimationController())->synchronizedAnimations()); + + RefPtr<CCLayerImpl> ccLayerTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), 0); + ccLayerTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), ccLayerTreeRoot.get()); + + EXPECT_TRUE(static_cast<FakeLayerAnimationController*>(layerTreeRoot->layerAnimationController())->synchronizedAnimations()); +} } // namespace diff --git a/Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp b/Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp index ad5810524..459255e02 100644 --- a/Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp +++ b/Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp @@ -67,14 +67,13 @@ public: private: virtual void setNeedsRedraw() OVERRIDE { } - virtual ScrollStatus scrollBegin(const WebCore::IntPoint&) OVERRIDE + virtual ScrollStatus scrollBegin(const WebCore::IntPoint&, WebCore::CCInputHandlerClient::ScrollInputType) OVERRIDE { return m_scrollStatus; } virtual void scrollBy(const WebCore::IntSize&) OVERRIDE { } virtual void scrollEnd() OVERRIDE { } - virtual bool haveWheelEventHandlers() OVERRIDE { return false; } virtual void pinchGestureBegin() OVERRIDE { m_pinchStarted = true; diff --git a/Source/WebKit/chromium/tests/WebFrameTest.cpp b/Source/WebKit/chromium/tests/WebFrameTest.cpp index b59001860..f61e98648 100644 --- a/Source/WebKit/chromium/tests/WebFrameTest.cpp +++ b/Source/WebKit/chromium/tests/WebFrameTest.cpp @@ -151,6 +151,78 @@ TEST_F(WebFrameTest, ChromePageNoJavascript) EXPECT_EQ(std::string::npos, content.find("Clobbered")); } +#if ENABLE(GESTURE_EVENTS) +TEST_F(WebFrameTest, DivAutoZoomParamsTest) +{ + registerMockedHttpURLLoad("get_scale_for_auto_zoom_into_div_test.html"); + + WebViewImpl* webViewImpl = static_cast<WebViewImpl*>(FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_scale_for_auto_zoom_into_div_test.html", true)); + int pageWidth = 640; + int pageHeight = 480; + int divPosX = 200; + int divPosY = 200; + int divWidth = 200; + int divHeight = 150; + WebRect doubleTapPoint(250, 250, 0, 0); + webViewImpl->resize(WebSize(pageWidth, pageHeight)); + float scale; + WebPoint scroll; + + // Test for Doubletap scaling + + // Tests for zooming in and out without clamping. + // Set device scale and scale limits so we dont get clamped. + webViewImpl->setDeviceScaleFactor(4); + webViewImpl->setPageScaleFactorLimits(0, 4 / webViewImpl->deviceScaleFactor()); + + // Test zooming into div. + webViewImpl->computeScaleAndScrollForHitRect(doubleTapPoint, WebViewImpl::DoubleTap, scale, scroll); + float scaledDivWidth = divWidth * scale; + float scaledDivHeight = divHeight * scale; + int hScroll = ((divPosX * scale) - ((pageWidth - scaledDivWidth) / 2)) / scale; + int vScroll = ((divPosY * scale) - ((pageHeight - scaledDivHeight) / 2)) / scale; + EXPECT_NEAR(pageWidth / divWidth, scale, 0.1); + EXPECT_EQ(hScroll, scroll.x); + EXPECT_EQ(vScroll, scroll.y); + + // Test zoom out to overview scale. + webViewImpl->applyScrollAndScale(WebCore::IntSize(scroll.x, scroll.y), scale / webViewImpl->pageScaleFactor()); + webViewImpl->computeScaleAndScrollForHitRect(doubleTapPoint, WebViewImpl::DoubleTap, scale, scroll); + EXPECT_FLOAT_EQ(1, scale); + EXPECT_EQ(WebPoint(0, 0), scroll); + + // Tests for clamped scaling. + // Test clamp to device scale: + webViewImpl->applyScrollAndScale(WebCore::IntSize(scroll.x, scroll.y), scale / webViewImpl->pageScaleFactor()); + webViewImpl->setDeviceScaleFactor(2.5); + webViewImpl->computeScaleAndScrollForHitRect(doubleTapPoint, WebViewImpl::DoubleTap, scale, scroll); + EXPECT_FLOAT_EQ(2.5, scale); + + // Test clamp to minimum scale: + webViewImpl->applyScrollAndScale(WebCore::IntSize(scroll.x, scroll.y), scale / webViewImpl->pageScaleFactor()); + webViewImpl->setPageScaleFactorLimits(1.5 / webViewImpl->deviceScaleFactor(), 4 / webViewImpl->deviceScaleFactor()); + webViewImpl->computeScaleAndScrollForHitRect(doubleTapPoint, WebViewImpl::DoubleTap, scale, scroll); + EXPECT_FLOAT_EQ(1.5, scale); + EXPECT_EQ(WebPoint(0, 0), scroll); + + // Test clamp to maximum scale: + webViewImpl->applyScrollAndScale(WebCore::IntSize(scroll.x, scroll.y), scale / webViewImpl->pageScaleFactor()); + webViewImpl->setDeviceScaleFactor(4); + webViewImpl->setPageScaleFactorLimits(0, 3 / webViewImpl->deviceScaleFactor()); + webViewImpl->computeScaleAndScrollForHitRect(doubleTapPoint, WebViewImpl::DoubleTap, scale, scroll); + EXPECT_FLOAT_EQ(3, scale); + + + // Test for Non-doubletap scaling + webViewImpl->setPageScaleFactor(1, WebPoint(0, 0)); + webViewImpl->setDeviceScaleFactor(4); + webViewImpl->setPageScaleFactorLimits(0, 4 / webViewImpl->deviceScaleFactor()); + // Test zooming into div. + webViewImpl->computeScaleAndScrollForHitRect(WebRect(250, 250, 10, 10), WebViewImpl::FindInPage, scale, scroll); + EXPECT_NEAR(pageWidth / divWidth, scale, 0.1); +} +#endif + class TestReloadDoesntRedirectWebFrameClient : public WebFrameClient { public: virtual WebNavigationPolicy decidePolicyForNavigation( diff --git a/Source/WebKit/chromium/tests/WebSocketDeflaterTest.cpp b/Source/WebKit/chromium/tests/WebSocketDeflaterTest.cpp new file mode 100644 index 000000000..423a5969f --- /dev/null +++ b/Source/WebKit/chromium/tests/WebSocketDeflaterTest.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "WebSocketDeflater.h" + +#include <gtest/gtest.h> +#include <wtf/Vector.h> + +using namespace WebCore; + +namespace { + +TEST(WebSocketDeflaterTest, TestCompressHello) +{ + // Test the first example on section 4.3 of the specification. + OwnPtr<WebSocketDeflater> deflater = WebSocketDeflater::create(15); + ASSERT_TRUE(deflater->initialize()); + OwnPtr<WebSocketInflater> inflater = WebSocketInflater::create(); + ASSERT_TRUE(inflater->initialize()); + const char* inputData = "Hello"; + const size_t inputLength = strlen(inputData); + + ASSERT_TRUE(deflater->addBytes(inputData, inputLength)); + ASSERT_TRUE(deflater->finish()); + const char expectedFirst[] = {0xf2, 0x48, 0xcd, 0xc9, 0xc9, 0x07, 0x00}; + EXPECT_EQ(sizeof(expectedFirst), deflater->size()); + EXPECT_EQ(0, memcmp(expectedFirst, deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->addBytes(deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->finish()); + EXPECT_EQ(inputLength, inflater->size()); + EXPECT_EQ(0, memcmp(inputData, inflater->data(), inflater->size())); + + deflater->reset(); + inflater->reset(); + + ASSERT_TRUE(deflater->addBytes(inputData, inputLength)); + ASSERT_TRUE(deflater->finish()); + const char expectedSecond[] = {0xf2, 0x00, 0x11, 0x00, 0x00}; + EXPECT_EQ(sizeof(expectedSecond), deflater->size()); + EXPECT_EQ(0, memcmp(expectedSecond, deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->addBytes(deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->finish()); + EXPECT_EQ(inputLength, inflater->size()); + EXPECT_EQ(0, memcmp(inputData, inflater->data(), inflater->size())); +} + +TEST(WebSocketDeflaterTest, TestMultipleAddBytesCalls) +{ + OwnPtr<WebSocketDeflater> deflater = WebSocketDeflater::create(15); + ASSERT_TRUE(deflater->initialize()); + OwnPtr<WebSocketInflater> inflater = WebSocketInflater::create(); + ASSERT_TRUE(inflater->initialize()); + Vector<char> inputData(32); + inputData.fill('a'); + + for (size_t i = 0; i < inputData.size(); ++i) + ASSERT_TRUE(deflater->addBytes(inputData.data() + i, 1)); + ASSERT_TRUE(deflater->finish()); + for (size_t i = 0; i < deflater->size(); ++i) + ASSERT_TRUE(inflater->addBytes(deflater->data() + i, 1)); + ASSERT_TRUE(inflater->finish()); + EXPECT_EQ(inputData.size(), inflater->size()); + EXPECT_EQ(0, memcmp(inputData.data(), inflater->data(), inflater->size())); +} + +TEST(WebSocketDeflaterTest, TestNoContextTakeOver) +{ + OwnPtr<WebSocketDeflater> deflater = WebSocketDeflater::create(15, WebSocketDeflater::DoNotTakeOverContext); + ASSERT_TRUE(deflater->initialize()); + OwnPtr<WebSocketInflater> inflater = WebSocketInflater::create(); + ASSERT_TRUE(inflater->initialize()); + const char expected[] = {0xf2, 0x48, 0xcd, 0xc9, 0xc9, 0x07, 0x00}; + const char* inputData = "Hello"; + const size_t inputLength = strlen(inputData); + + // If we don't take over context, the second result should be the identical + // with the first one. + for (size_t i = 0; i < 2; ++i) { + ASSERT_TRUE(deflater->addBytes(inputData, inputLength)); + ASSERT_TRUE(deflater->finish()); + EXPECT_EQ(sizeof(expected), deflater->size()); + EXPECT_EQ(0, memcmp(expected, deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->addBytes(deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->finish()); + EXPECT_EQ(inputLength, inflater->size()); + EXPECT_EQ(0, memcmp(inputData, inflater->data(), inflater->size())); + deflater->reset(); + inflater->reset(); + } +} + +TEST(WebSocketDeflaterTest, TestWindowBits) +{ + Vector<char> inputData(1024 + 64 * 2); + inputData.fill('a'); + // Modify the head and tail of the inputData so that back-reference + // can be used if the window size is sufficiently-large. + for (size_t j = 0; j < 64; ++j) { + inputData[j] = 'b'; + inputData[inputData.size() - j - 1] = 'b'; + } + + OwnPtr<WebSocketDeflater> deflater = WebSocketDeflater::create(8); + ASSERT_TRUE(deflater->initialize()); + ASSERT_TRUE(deflater->addBytes(inputData.data(), inputData.size())); + ASSERT_TRUE(deflater->finish()); + + OwnPtr<WebSocketInflater> inflater = WebSocketInflater::create(8); + ASSERT_TRUE(inflater->initialize()); + ASSERT_TRUE(inflater->addBytes(deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->finish()); + EXPECT_EQ(inputData.size(), inflater->size()); + EXPECT_EQ(0, memcmp(inputData.data(), inflater->data(), inflater->size())); +} + +TEST(WebSocketDeflaterTest, TestLargeData) +{ + OwnPtr<WebSocketDeflater> deflater = WebSocketDeflater::create(15); + ASSERT_TRUE(deflater->initialize()); + OwnPtr<WebSocketInflater> inflater = WebSocketInflater::create(); + ASSERT_TRUE(inflater->initialize()); + Vector<char> inputData(16 * 1024 * 1024); + inputData.fill('a'); + + ASSERT_TRUE(deflater->addBytes(inputData.data(), inputData.size())); + ASSERT_TRUE(deflater->finish()); + ASSERT_TRUE(inflater->addBytes(deflater->data(), deflater->size())); + ASSERT_TRUE(inflater->finish()); + EXPECT_EQ(inputData.size(), inflater->size()); + EXPECT_EQ(0, memcmp(inputData.data(), inflater->data(), inflater->size())); +} + +} diff --git a/Source/WebKit/chromium/tests/WebSocketExtensionDispatcherTest.cpp b/Source/WebKit/chromium/tests/WebSocketExtensionDispatcherTest.cpp new file mode 100644 index 000000000..358983b83 --- /dev/null +++ b/Source/WebKit/chromium/tests/WebSocketExtensionDispatcherTest.cpp @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "WebSocketExtensionDispatcher.h" + +#include "WebSocketExtensionProcessor.h" + +#include <gtest/gtest.h> +#include <wtf/text/StringHash.h> + +using namespace WebCore; + +namespace { + +class WebSocketExtensionDispatcherTest; + +class MockWebSocketExtensionProcessor : public WebSocketExtensionProcessor { +public: + MockWebSocketExtensionProcessor(const String& name, WebSocketExtensionDispatcherTest* test) + : WebSocketExtensionProcessor(name) + , m_test(test) + { + } + virtual String handshakeString() OVERRIDE { return extensionToken(); } + virtual bool processResponse(const HashMap<String, String>&) OVERRIDE; + +private: + WebSocketExtensionDispatcherTest* m_test; +}; + +class WebSocketExtensionDispatcherTest : public testing::Test { +public: + WebSocketExtensionDispatcherTest() { } + + void SetUp() { } + + void TearDown() { } + + void addMockProcessor(const String& extensionToken) + { + m_extensions.addProcessor(adoptPtr(new MockWebSocketExtensionProcessor(extensionToken, this))); + + } + + void appendResult(const String& extensionToken, const HashMap<String, String>& parameters) + { + m_parsedExtensionTokens.append(extensionToken); + m_parsedParameters.append(parameters); + } + +protected: + WebSocketExtensionDispatcher m_extensions; + Vector<String> m_parsedExtensionTokens; + Vector<HashMap<String, String> > m_parsedParameters; +}; + +bool MockWebSocketExtensionProcessor::processResponse(const HashMap<String, String>& parameters) +{ + m_test->appendResult(extensionToken(), parameters); + return true; +} + +TEST_F(WebSocketExtensionDispatcherTest, TestSingle) +{ + addMockProcessor("deflate-frame"); + EXPECT_TRUE(m_extensions.processHeaderValue("deflate-frame")); + EXPECT_EQ(1UL, m_parsedExtensionTokens.size()); + EXPECT_EQ("deflate-frame", m_parsedExtensionTokens[0]); + EXPECT_EQ("deflate-frame", m_extensions.acceptedExtensions()); + EXPECT_EQ(0, m_parsedParameters[0].size()); +} + +TEST_F(WebSocketExtensionDispatcherTest, TestParameters) +{ + addMockProcessor("mux"); + EXPECT_TRUE(m_extensions.processHeaderValue("mux; max-channels=4; flow-control ")); + EXPECT_EQ(1UL, m_parsedExtensionTokens.size()); + EXPECT_EQ("mux", m_parsedExtensionTokens[0]); + EXPECT_EQ(2, m_parsedParameters[0].size()); + HashMap<String, String>::iterator parameter = m_parsedParameters[0].find("max-channels"); + EXPECT_TRUE(parameter != m_parsedParameters[0].end()); + EXPECT_EQ("4", parameter->second); + parameter = m_parsedParameters[0].find("flow-control"); + EXPECT_TRUE(parameter != m_parsedParameters[0].end()); + EXPECT_TRUE(parameter->second.isNull()); +} + +TEST_F(WebSocketExtensionDispatcherTest, TestMultiple) +{ + struct { + String token; + HashMap<String, String> parameters; + } expected[2]; + expected[0].token = "mux"; + expected[0].parameters.add("max-channels", "4"); + expected[0].parameters.add("flow-control", String()); + expected[1].token = "deflate-frame"; + + addMockProcessor("mux"); + addMockProcessor("deflate-frame"); + EXPECT_TRUE(m_extensions.processHeaderValue("mux ; max-channels =4;flow-control, deflate-frame ")); + EXPECT_TRUE(m_extensions.acceptedExtensions().find("mux") != notFound); + EXPECT_TRUE(m_extensions.acceptedExtensions().find("deflate-frame") != notFound); + for (size_t i = 0; i < sizeof(expected) / sizeof(expected[0]); ++i) { + EXPECT_EQ(expected[i].token, m_parsedExtensionTokens[i]); + const HashMap<String, String>& expectedParameters = expected[i].parameters; + const HashMap<String, String>& parsedParameters = m_parsedParameters[i]; + EXPECT_EQ(expected[i].parameters.size(), m_parsedParameters[i].size()); + for (HashMap<String, String>::const_iterator iterator = expectedParameters.begin(); iterator != expectedParameters.end(); ++iterator) { + HashMap<String, String>::const_iterator parsed = parsedParameters.find(iterator->first); + EXPECT_TRUE(parsed != parsedParameters.end()); + if (iterator->second.isNull()) + EXPECT_TRUE(parsed->second.isNull()); + else + EXPECT_EQ(iterator->second, parsed->second); + } + } +} + +TEST_F(WebSocketExtensionDispatcherTest, TestQuotedString) +{ + addMockProcessor("x-foo"); + EXPECT_TRUE(m_extensions.processHeaderValue("x-foo; param1=\"quoted string\"; param2=\"\\\"quoted\\\" string\\\\\"")); + EXPECT_EQ(2, m_parsedParameters[0].size()); + EXPECT_EQ("quoted string", m_parsedParameters[0].get("param1")); + EXPECT_EQ("\"quoted\" string\\", m_parsedParameters[0].get("param2")); +} + +TEST_F(WebSocketExtensionDispatcherTest, TestInvalid) +{ + const char* inputs[] = { + "\"x-foo\"", + "x-baz", + "x-foo\\", + "x-(foo)", + "x-foo; ", + "x-foo; bar=", + "x-foo; bar=x y", + "x-foo; bar=\"mismatch quote", + "x-foo; bar=\"\\\"", + "x-foo; \"bar\"=baz", + "x-foo x-bar", + "x-foo, x-baz" + "x-foo, ", + }; + for (size_t i = 0; i < sizeof(inputs) / sizeof(inputs[0]); ++i) { + m_extensions.reset(); + addMockProcessor("x-foo"); + addMockProcessor("x-bar"); + EXPECT_FALSE(m_extensions.processHeaderValue(inputs[i])); + EXPECT_TRUE(m_extensions.acceptedExtensions().isNull()); + } +} + +} diff --git a/Source/WebKit/chromium/tests/WebURLResponseTest.cpp b/Source/WebKit/chromium/tests/WebURLResponseTest.cpp new file mode 100644 index 000000000..112ed8601 --- /dev/null +++ b/Source/WebKit/chromium/tests/WebURLResponseTest.cpp @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "platform/WebURLResponse.h" + +#include <gtest/gtest.h> + +using namespace WebKit; + +namespace { + +class TestExtraData : public WebURLResponse::ExtraData { +public: + explicit TestExtraData(bool* alive) + : m_alive(alive) + { + *alive = true; + } + + virtual ~TestExtraData() { *m_alive = false; } + +private: + bool* m_alive; +}; + +TEST(WebURLResponseTest, ExtraData) +{ + bool alive = false; + { + WebURLResponse urlResponse; + TestExtraData* extraData = new TestExtraData(&alive); + EXPECT_TRUE(alive); + + urlResponse.initialize(); + urlResponse.setExtraData(extraData); + EXPECT_EQ(extraData, urlResponse.extraData()); + { + WebURLResponse otherUrlResponse = urlResponse; + EXPECT_TRUE(alive); + EXPECT_EQ(extraData, otherUrlResponse.extraData()); + EXPECT_EQ(extraData, urlResponse.extraData()); + } + EXPECT_TRUE(alive); + EXPECT_EQ(extraData, urlResponse.extraData()); + } + EXPECT_FALSE(alive); +} + +} // namespace diff --git a/Source/WebKit/chromium/tests/data/get_scale_for_auto_zoom_into_div_test.html b/Source/WebKit/chromium/tests/data/get_scale_for_auto_zoom_into_div_test.html new file mode 100644 index 000000000..1817dc47d --- /dev/null +++ b/Source/WebKit/chromium/tests/data/get_scale_for_auto_zoom_into_div_test.html @@ -0,0 +1,13 @@ +<html> + <body> + <div style="background-color: green; position: absolute; left: 0px; top: 0px; width: 640px; height: 480px"> + <p>Top Div</p> + <div style="background-color: white; position: absolute; left: 200px; top: 200px; width: 200px; height: 150px"> + <p id="innerDiv">Div to zoom to</p> + <div style="background-color: red; position: fixed; left: 220px; top: 350px; width: 160px; height: 40px"> + <p id="innerInnerDiv">Div NOT to zoom to</p> + </div> + </div> + </div> + </body> +</html> diff --git a/Source/WebKit/efl/ChangeLog b/Source/WebKit/efl/ChangeLog index 6a52fa252..db22d44eb 100644 --- a/Source/WebKit/efl/ChangeLog +++ b/Source/WebKit/efl/ChangeLog @@ -1,3 +1,245 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/EditorClientEfl.h: + (WebCore::EditorClientEfl::requestCheckingOfString): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientEfl.cpp: + (WebCore::EditorClientEfl::shouldApplyStyle): + * WebCoreSupport/EditorClientEfl.h: + (EditorClientEfl): + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientEfl.cpp: + (WebCore::EditorClientEfl::shouldApplyStyle): + * WebCoreSupport/EditorClientEfl.h: + (EditorClientEfl): + +2012-02-20 Kihong Kwon <kihong.kwon@samsung.com> + + Add a new API for the Vibration API(W3C). + https://bugs.webkit.org/show_bug.cgi?id=72010 + + Reviewed by Hajime Morita. + + Implementation for the Vibration API feature to the EFL-port layer. + http://dev.w3.org/2009/dap/vibration/ + There are two methods for vibration API. + - vibrate : Vibrate device for receiving as a parameter. + - cancelVibrate : Cancel current vibration. + + * CMakeListsEfl.txt: + * WebCoreSupport/VibrationClientEfl.cpp: Added. + (WebCore): + (WebCore::VibrationClientEfl::VibrationClientEfl): + (WebCore::VibrationClientEfl::vibrate): + (WebCore::VibrationClientEfl::cancelVibration): + (WebCore::VibrationClientEfl::vibrationDestroyed): + * WebCoreSupport/VibrationClientEfl.h: Added. + (WebCore): + (VibrationClientEfl): + (WebCore::VibrationClientEfl::~VibrationClientEfl): + * ewk/ewk_view.cpp: + (_Ewk_View_Private_Data): + (_ewk_view_priv_new): + +2012-02-17 Raphael Kubo da Costa <kubo@profusion.mobi> + + [EFL] Unreviewed, adapt to the changes introduced in r107973. + + SVN r107973 moved some libsoup feature initialization code to + WebCore, but only changed the GTK+ bits in WebKit. + + * ewk/ewk_main.cpp: + (_ewk_init_body): Do not initialize the content sniffer and the + decoder here, the initialization is now done in WebCore. + +2012-02-17 Raphael Kubo da Costa <kubo@profusion.mobi> + + Unreviewed, fix the build with ENABLE(DEVICE_ORIENTATION) after + r107518. The EFL EWS bot doesn't enable that flag, so the breakage + was not spotted earlier. + + * ewk/ewk_view.cpp: + (_Ewk_View_Private_Data): + (_ewk_view_priv_new): + +2012-01-31 Raphael Kubo da Costa <kubo@profusion.mobi> + + [soup] Add support for multiple SoupSessions. + https://bugs.webkit.org/show_bug.cgi?id=77341 + + Add the necessary infrastructure to support multiple SoupSessions. Each + WebView now has a "session" property, which defaults to + ResourceHandle::defaultSession() and can be changed to another + SoupSession by the user. + + Some API in ewk_network and ewk_view which required SoupSession to be a + valid type in the headers has now been moved inside #if USE(SOUP) + ifdefs so we can actually the required Soup header and avoid build + problems with duplicate typedefs. + + * CMakeListsEfl.txt: + * WebCoreSupport/FrameLoaderClientEfl.cpp: + (WebCore::FrameLoaderClientEfl::createNetworkingContext): + * WebCoreSupport/FrameNetworkingContextEfl.cpp: Copied from Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.h. + (WebCore): + (WebCore::FrameNetworkingContextEfl::create): + (WebCore::FrameNetworkingContextEfl::FrameNetworkingContextEfl): + (WebCore::FrameNetworkingContextEfl::soupSession): + * WebCoreSupport/FrameNetworkingContextEfl.h: + (FrameNetworkingContextEfl): + * ewk/ewk_cookies.h: Mention this API is only valid with the + default SoupSession. + * ewk/ewk_network.cpp: + (ewk_network_default_soup_session_get): Define only if USE(SOUP) is set. + * ewk/ewk_network.h: Ditto, and mention this API is only valid with the + default SoupSession. + * ewk/ewk_view.cpp: + (_Ewk_View_Private_Data): + (_ewk_view_priv_new): + (ewk_view_soup_session_get): + (ewk_view_soup_session_set): + * ewk/ewk_view.h: + (): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebCoreSupport/ChromeClientEfl.h: + (WebCore::ChromeClientEfl::numTouchEventHandlersChanged): + +2012-02-15 Gustavo Lima Chaves <glima@profusion.mobi> + + [EFL] Add missing libsoup to (pkgconfig) dependency requirements + https://bugs.webkit.org/show_bug.cgi?id=78702 + + Unreviewed build fix. + + * ewebkit.pc.in: Now that bug 77874 had its patch landed, we + always require libsoup as a dependency for the EFL port. The + 'Require' session of this file has to contemplate that, otherwise + code linking with ewebkit will fail to lookup to libsoup's header + files. + +2012-02-13 Raphael Kubo da Costa <kubo@profusion.mobi> + + [CMake] Merge WebKitEfl.cmake into FindEFL.cmake. + https://bugs.webkit.org/show_bug.cgi?id=78566 + + Reviewed by Daniel Bates. + + * CMakeListsEfl.txt: Do not include WebKitEfl.cmake. + +2012-02-11 Nikolas Zimmermann <nzimmermann@rim.com> + + Convert svg/animations to use SMIL methods for driving the timeline + https://bugs.webkit.org/show_bug.cgi?id=78422 + + Reviewed by Dirk Schulze. + + Remove SVG animation sampling functionality provided for DRT, which no longer uses it. + Instead we switched the svg/animations tests to use SVGSVGElement.setCurrentTime. + + * WebCoreSupport/DumpRenderTreeSupportEfl.cpp: + * WebCoreSupport/DumpRenderTreeSupportEfl.h: + +2012-02-06 Raphael Kubo da Costa <kubo@profusion.mobi> + + [EFL] Drop support for the Curl network backend. + https://bugs.webkit.org/show_bug.cgi?id=77874 + + Reviewed by Eric Seidel. + + Nobody seems to be maintaining the Curl backend in WebCore, the + EFL port developers all seem to be using the Soup backend and the + port itself has many features which are only implemented for the + latter. + + * CMakeListsEfl.txt: Unconditionally build soup-dependent files + and always add the glib/soup include directories and libraries. + * WebCoreSupport/FrameLoaderClientEfl.cpp: + (WebCore::FrameLoaderClientEfl::dispatchDidReceiveResponse): + Remove USE(SOUP) checks. + * ewk/ewk_auth.cpp: + (ewk_auth_show_dialog_callback_set): Ditto. + (ewk_auth_credentials_set): Ditto. + * ewk/ewk_cookies.cpp: + (ewk_cookies_file_set): Ditto. + (ewk_cookies_clear): Ditto. + (ewk_cookies_get_all): Ditto. + (ewk_cookies_cookie_del): Ditto. + (ewk_cookies_cookie_free): Ditto. + (ewk_cookies_policy_set): Ditto. + (ewk_cookies_policy_get): Ditto. + * ewk/ewk_frame.cpp: + (ewk_frame_certificate_status_get): Ditto. + * ewk/ewk_main.cpp: + (_ewk_init_body): Ditto. + * ewk/ewk_network.cpp: + (ewk_network_proxy_uri_set): Ditto. + (ewk_network_proxy_uri_get): Ditto. + (ewk_network_tls_certificate_check_get): Ditto. + (ewk_network_tls_certificate_check_set): Ditto. + (ewk_network_tls_ca_certificates_path_get): Ditto. + (ewk_network_tls_ca_certificates_path_set): Ditto. + (ewk_network_default_soup_session_get): Ditto. + * ewk/ewk_network.h: Update apidox for + ewk_network_default_soup_session_get() now that libsoup is the + only available backend. + +2012-02-09 Gustavo Lima Chaves <glima@profusion.mobi> + + [EFL] Introducing functions to set local storage db path and clear + those dbs. + https://bugs.webkit.org/show_bug.cgi?id=77107 + + This patch exposes the web local storage tracker database path + setting cabability, introduced on bug 77006, to the EFL port of + WebKit. Particularly, we have our own storage tracker client + object, to initialize the storage tracker backend on ewk_init(). + + Reviewed by Kenneth Rohde Christiansen. + + * CMakeListsEfl.txt: + * WebCoreSupport/StorageTrackerClientEfl.cpp: Added. + (WebCore): + (WebCore::StorageTrackerClientEfl::dispatchDidModifyOrigin): + (WebCore::StorageTrackerClientEfl::didFinishLoadingOrigins): + * WebCoreSupport/StorageTrackerClientEfl.h: Added. + (WebCore): + (StorageTrackerClientEfl): + * ewk/ewk_main.cpp: + (trackerClient): + (_ewk_init_body): + * ewk/ewk_settings.cpp: + (ewk_settings_local_storage_path_set): + (ewk_settings_local_storage_path_get): + (ewk_settings_local_storage_database_clear): + (ewk_settings_local_storage_database_origin_clear): + * ewk/ewk_settings.h: + 2012-02-07 Krzysztof Czech <k.czech@samsung.com> [EFL] Add missing initialization of editable variable. diff --git a/Source/WebKit/efl/WebCoreSupport/ChromeClientEfl.h b/Source/WebKit/efl/WebCoreSupport/ChromeClientEfl.h index 4b47c731c..82512251f 100644 --- a/Source/WebKit/efl/WebCoreSupport/ChromeClientEfl.h +++ b/Source/WebKit/efl/WebCoreSupport/ChromeClientEfl.h @@ -173,6 +173,7 @@ public: virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const { return true; } virtual void numWheelEventHandlersChanged(unsigned) { } + virtual void numTouchEventHandlersChanged(unsigned) { } Evas_Object* m_view; KURL m_hoveredLinkURL; diff --git a/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.cpp b/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.cpp index 1eb58d5b5..2a4a9fcc9 100644 --- a/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.cpp +++ b/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.cpp @@ -40,11 +40,6 @@ #include <workers/WorkerThread.h> #include <wtf/text/AtomicString.h> -#if ENABLE(SVG) -#include <SVGDocumentExtensions.h> -#include <SVGSMILElement.h> -#endif - unsigned DumpRenderTreeSupportEfl::activeAnimationsCount(const Evas_Object* ewkFrame) { WebCore::Frame* frame = EWKPrivate::coreFrame(ewkFrame); @@ -174,30 +169,6 @@ bool DumpRenderTreeSupportEfl::pauseAnimation(Evas_Object* ewkFrame, const char* return frame->animation()->pauseAnimationAtTime(element->renderer(), name, time); } -bool DumpRenderTreeSupportEfl::pauseSVGAnimation(Evas_Object* ewkFrame, const char* animationId, const char* elementId, double time) -{ -#if ENABLE(SVG) - WebCore::Frame* frame = EWKPrivate::coreFrame(ewkFrame); - - if (!frame) - return false; - - WebCore::Document* document = frame->document(); - - if (!document || !document->svgExtensions()) - return false; - - WebCore::Element* element = document->getElementById(animationId); - - if (!element || !WebCore::SVGSMILElement::isSMILElement(element)) - return false; - - return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<WebCore::SVGSMILElement*>(element), time); -#else - return false; -#endif -} - bool DumpRenderTreeSupportEfl::pauseTransition(Evas_Object* ewkFrame, const char* name, const char* elementId, double time) { WebCore::Frame* frame = EWKPrivate::coreFrame(ewkFrame); diff --git a/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.h b/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.h index 0ba342a6d..42af811d3 100644 --- a/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.h +++ b/Source/WebKit/efl/WebCoreSupport/DumpRenderTreeSupportEfl.h @@ -52,7 +52,6 @@ public: static int numberOfPages(const Evas_Object* ewkFrame, float pageWidth, float pageHeight); static int numberOfPagesForElementId(const Evas_Object* ewkFrame, const char* elementId, float pageWidth, float pageHeight); static bool pauseAnimation(Evas_Object* ewkFrame, const char* name, const char* elementId, double time); - static bool pauseSVGAnimation(Evas_Object* ewkFrame, const char* animationId, const char* elementId, double time); static bool pauseTransition(Evas_Object* ewkFrame, const char* name, const char* elementId, double time); static unsigned pendingUnloadEventCount(const Evas_Object* ewkFrame); static String renderTreeDump(Evas_Object* ewkFrame); diff --git a/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.cpp b/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.cpp index 78563ec7d..8224155a8 100644 --- a/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.cpp +++ b/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.cpp @@ -103,7 +103,7 @@ bool EditorClientEfl::shouldChangeSelectedRange(Range*, Range*, EAffinity, bool) return true; } -bool EditorClientEfl::shouldApplyStyle(CSSStyleDeclaration*, Range*) +bool EditorClientEfl::shouldApplyStyle(StylePropertySet*, Range*) { notImplemented(); return true; diff --git a/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.h b/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.h index 7ff181316..2b52e9dda 100644 --- a/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.h +++ b/Source/WebKit/efl/WebCoreSupport/EditorClientEfl.h @@ -73,7 +73,7 @@ public: virtual bool shouldInsertText(const String&, Range*, EditorInsertAction); virtual bool shouldChangeSelectedRange(Range* fromRange, Range* toRange, EAffinity, bool stillSelecting); - virtual bool shouldApplyStyle(CSSStyleDeclaration*, Range*); + virtual bool shouldApplyStyle(StylePropertySet*, Range*); virtual bool shouldMoveRangeAfterDelete(Range*, Range*); @@ -120,7 +120,7 @@ public: virtual void getGuessesForWord(const String& word, const String& context, WTF::Vector<String>& guesses); virtual void willSetInputMethodState(); virtual void setInputMethodState(bool enabled); - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&) { } + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&) { } virtual TextCheckerClient* textChecker() { return this; } private: diff --git a/Source/WebKit/efl/WebCoreSupport/FrameLoaderClientEfl.cpp b/Source/WebKit/efl/WebCoreSupport/FrameLoaderClientEfl.cpp index 1d4d64a9f..0096b8874 100644 --- a/Source/WebKit/efl/WebCoreSupport/FrameLoaderClientEfl.cpp +++ b/Source/WebKit/efl/WebCoreSupport/FrameLoaderClientEfl.cpp @@ -241,13 +241,9 @@ void FrameLoaderClientEfl::frameLoaderDestroyed() void FrameLoaderClientEfl::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long, const ResourceResponse& response) { -#if USE(SOUP) // Update our knowledge of request soup flags - some are only set // after the request is done. loader->request().setSoupMessageFlags(response.soupMessageFlags()); -#else - UNUSED_PARAM(loader); -#endif m_response = response; } @@ -951,7 +947,7 @@ void FrameLoaderClientEfl::dispatchDidBecomeFrameset(bool) PassRefPtr<FrameNetworkingContext> FrameLoaderClientEfl::createNetworkingContext() { - return FrameNetworkingContextEfl::create(EWKPrivate::coreFrame(m_frame)); + return FrameNetworkingContextEfl::create(EWKPrivate::coreFrame(m_frame), m_frame); } } diff --git a/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.cpp b/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.cpp new file mode 100644 index 000000000..8c20b213a --- /dev/null +++ b/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) + * Copyright (C) 2010 Samsung Electronics + * Copyright (C) 2012 ProFUSION embedded systems + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "FrameNetworkingContextEfl.h" + +#include "ResourceHandle.h" +#include "ewk_frame.h" +#include "ewk_view.h" + +#include <Evas.h> + +namespace WebCore { + +PassRefPtr<FrameNetworkingContextEfl> FrameNetworkingContextEfl::create(Frame* frame, Evas_Object* ewkFrame) +{ + return adoptRef(new FrameNetworkingContextEfl(frame, ewkFrame)); +} + +FrameNetworkingContextEfl::FrameNetworkingContextEfl(Frame* frame, Evas_Object* ewkFrame) + : FrameNetworkingContext(frame) + , m_ewkFrame(ewkFrame) +{ +} + +SoupSession* FrameNetworkingContextEfl::soupSession() const +{ + return ewk_view_soup_session_get(ewk_frame_view_get(m_ewkFrame)); +} + +} diff --git a/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.h b/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.h index 4e67512d0..93ffd48bb 100644 --- a/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.h +++ b/Source/WebKit/efl/WebCoreSupport/FrameNetworkingContextEfl.h @@ -31,22 +31,21 @@ #include "FrameNetworkingContext.h" +typedef struct _Evas_Object Evas_Object; + namespace WebCore { class FrameNetworkingContextEfl : public WebCore::FrameNetworkingContext { public: - static PassRefPtr<FrameNetworkingContextEfl> create(WebCore::Frame* frame) - { - return adoptRef(new FrameNetworkingContextEfl(frame)); - } + static PassRefPtr<FrameNetworkingContextEfl> create(Frame*, Evas_Object*); WebCore::Frame* coreFrame() const { return frame(); } + virtual SoupSession* soupSession() const; private: - FrameNetworkingContextEfl(WebCore::Frame* frame) - : WebCore::FrameNetworkingContext(frame) - { - } + FrameNetworkingContextEfl(Frame*, Evas_Object*); + + Evas_Object* m_ewkFrame; }; } diff --git a/Source/WebKit/efl/WebCoreSupport/StorageTrackerClientEfl.cpp b/Source/WebKit/efl/WebCoreSupport/StorageTrackerClientEfl.cpp new file mode 100644 index 000000000..9d9d26918 --- /dev/null +++ b/Source/WebKit/efl/WebCoreSupport/StorageTrackerClientEfl.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012 ProFUSION Embedded Systems + * + * 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 "StorageTrackerClientEfl.h" + +#include "NotImplemented.h" + +namespace WebCore { + +void StorageTrackerClientEfl::dispatchDidModifyOrigin(const String&) +{ + notImplemented(); +} + +void StorageTrackerClientEfl::didFinishLoadingOrigins() +{ + notImplemented(); +} + +} diff --git a/Source/WebKit/efl/WebCoreSupport/StorageTrackerClientEfl.h b/Source/WebKit/efl/WebCoreSupport/StorageTrackerClientEfl.h new file mode 100644 index 000000000..62eae20ee --- /dev/null +++ b/Source/WebKit/efl/WebCoreSupport/StorageTrackerClientEfl.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2012 ProFUSION Embedded Systems + * + * 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. + */ + +#ifndef StorageTrackerClientEfl_h +#define StorageTrackerClientEfl_h + +#include "StorageTrackerClient.h" + +namespace WebCore { + +class StorageTrackerClientEfl : public StorageTrackerClient { +public: + virtual void dispatchDidModifyOrigin(const String&); + virtual void didFinishLoadingOrigins(); +}; + +} + +#endif // StorageTrackerClientEfl_h diff --git a/Source/WebKit/efl/WebCoreSupport/VibrationClientEfl.cpp b/Source/WebKit/efl/WebCoreSupport/VibrationClientEfl.cpp new file mode 100644 index 000000000..2365b72a3 --- /dev/null +++ b/Source/WebKit/efl/WebCoreSupport/VibrationClientEfl.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2012 Samsung Electronics + * + * 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 "VibrationClientEfl.h" + +#if ENABLE(VIBRATION) + +namespace WebCore { + +VibrationClientEfl::VibrationClientEfl(Evas_Object* view) + : m_view(view) +{ +} + +void VibrationClientEfl::vibrate(const unsigned long& time) +{ + evas_object_smart_callback_call(m_view, "vibration,vibrate", (void*)&time); +} + +void VibrationClientEfl::cancelVibration() +{ + evas_object_smart_callback_call(m_view, "vibration,cancel", 0); +} + +void VibrationClientEfl::vibrationDestroyed() +{ + delete this; +} + +} // namespace WebCore + +#endif // ENABLE(VIBRATION) + diff --git a/Source/WebKit/efl/WebCoreSupport/VibrationClientEfl.h b/Source/WebKit/efl/WebCoreSupport/VibrationClientEfl.h new file mode 100644 index 000000000..e7b0d925a --- /dev/null +++ b/Source/WebKit/efl/WebCoreSupport/VibrationClientEfl.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2012 Samsung Electronics + * + * 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. + */ + +#ifndef VibrationClientEfl_h +#define VibrationClientEfl_h + +#include "VibrationClient.h" +#include <Evas.h> + +namespace WebCore { + +class VibrationClientEfl : public VibrationClient { +public: + VibrationClientEfl(Evas_Object* view); + virtual ~VibrationClientEfl() { } + + virtual void vibrate(const unsigned long& time); + virtual void cancelVibration(); + + virtual void vibrationDestroyed(); + +private: + Evas_Object* m_view; +}; + +} // namespace WebCore + +#endif // VibrationClientEfl_h + diff --git a/Source/WebKit/efl/ewebkit.pc.in b/Source/WebKit/efl/ewebkit.pc.in index 3a1c8f54f..dd6178347 100644 --- a/Source/WebKit/efl/ewebkit.pc.in +++ b/Source/WebKit/efl/ewebkit.pc.in @@ -7,7 +7,7 @@ datadir=${prefix}/share/@WebKit_LIBRARY_NAME@-@PROJECT_VERSION_MAJOR@ Name: WebKit-EFL Description: Web content engine for EFL applications Version: @PROJECT_VERSION@ -Requires: cairo evas ecore +Requires: cairo evas ecore libsoup-2.4 Libs: -L${libdir} -lewebkit @EXTRA_EWEBKIT_LINK@ Libs.private: @LIBS_PRIVATE@ Cflags: -I${includedir}/@WebKit_LIBRARY_NAME@-@PROJECT_VERSION_MAJOR@ diff --git a/Source/WebKit/efl/ewk/ewk_auth.cpp b/Source/WebKit/efl/ewk/ewk_auth.cpp index a4cb9e6b7..af2172ae1 100644 --- a/Source/WebKit/efl/ewk/ewk_auth.cpp +++ b/Source/WebKit/efl/ewk/ewk_auth.cpp @@ -20,20 +20,14 @@ #include "config.h" #include "ewk_auth.h" -#ifdef WTF_USE_SOUP #include "ewk_auth_soup.h" -#endif void ewk_auth_show_dialog_callback_set(Ewk_Auth_Show_Dialog_Callback callback) { -#if USE(SOUP) ewk_auth_soup_show_dialog_callback_set(callback); -#endif } void ewk_auth_credentials_set(char* username, char* password, void* data) { -#if USE(SOUP) ewk_auth_soup_credentials_set(username, password, data); -#endif } diff --git a/Source/WebKit/efl/ewk/ewk_cookies.cpp b/Source/WebKit/efl/ewk/ewk_cookies.cpp index 35e64ac40..7980c0120 100644 --- a/Source/WebKit/efl/ewk/ewk_cookies.cpp +++ b/Source/WebKit/efl/ewk/ewk_cookies.cpp @@ -21,20 +21,16 @@ #include "config.h" #include "ewk_cookies.h" +#include "CookieJarSoup.h" #include "ResourceHandle.h" #include <Eina.h> #include <eina_safety_checks.h> -#include <wtf/text/CString.h> - -#if USE(SOUP) -#include "CookieJarSoup.h" #include <glib.h> #include <libsoup/soup.h> -#endif +#include <wtf/text/CString.h> Eina_Bool ewk_cookies_file_set(const char* filename) { -#if USE(SOUP) SoupCookieJar* cookieJar = 0; if (filename) cookieJar = soup_cookie_jar_text_new(filename, FALSE); @@ -55,14 +51,10 @@ Eina_Bool ewk_cookies_file_set(const char* filename) soup_session_add_feature(session, SOUP_SESSION_FEATURE(cookieJar)); return true; -#else - return false; -#endif } void ewk_cookies_clear(void) { -#if USE(SOUP) GSList* list; GSList* p; SoupCookieJar* cookieJar = WebCore::defaultCookieJar(); @@ -72,13 +64,11 @@ void ewk_cookies_clear(void) soup_cookie_jar_delete_cookie(cookieJar, (SoupCookie*)p->data); soup_cookies_free(list); -#endif } Eina_List* ewk_cookies_get_all(void) { Eina_List* result = 0; -#if USE(SOUP) GSList* list; GSList* p; SoupCookieJar* cookieJar = WebCore::defaultCookieJar(); @@ -98,13 +88,12 @@ Eina_List* ewk_cookies_get_all(void) } soup_cookies_free(list); -#endif + return result; } void ewk_cookies_cookie_del(Ewk_Cookie* cookie) { -#if USE(SOUP) EINA_SAFETY_ON_NULL_RETURN(cookie); GSList* list; GSList* p; @@ -123,24 +112,20 @@ void ewk_cookies_cookie_del(Ewk_Cookie* cookie) soup_cookie_free(cookie1); soup_cookies_free(list); -#endif } void ewk_cookies_cookie_free(Ewk_Cookie* cookie) { -#if USE(SOUP) EINA_SAFETY_ON_NULL_RETURN(cookie); free(cookie->name); free(cookie->value); free(cookie->domain); free(cookie->path); free(cookie); -#endif } void ewk_cookies_policy_set(Ewk_Cookie_Policy cookiePolicy) { -#if USE(SOUP) SoupCookieJar* cookieJar = WebCore::defaultCookieJar(); SoupCookieJarAcceptPolicy policy; @@ -158,13 +143,11 @@ void ewk_cookies_policy_set(Ewk_Cookie_Policy cookiePolicy) } soup_cookie_jar_set_accept_policy(cookieJar, policy); -#endif } Ewk_Cookie_Policy ewk_cookies_policy_get(void) { Ewk_Cookie_Policy ewkPolicy = EWK_COOKIE_JAR_ACCEPT_ALWAYS; -#if USE(SOUP) SoupCookieJar* cookieJar = WebCore::defaultCookieJar(); SoupCookieJarAcceptPolicy policy; @@ -180,7 +163,6 @@ Ewk_Cookie_Policy ewk_cookies_policy_get(void) ewkPolicy = EWK_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY; break; } -#endif return ewkPolicy; } diff --git a/Source/WebKit/efl/ewk/ewk_cookies.h b/Source/WebKit/efl/ewk/ewk_cookies.h index 40e69d56c..29ac12182 100644 --- a/Source/WebKit/efl/ewk/ewk_cookies.h +++ b/Source/WebKit/efl/ewk/ewk_cookies.h @@ -21,6 +21,12 @@ /** * @file ewk_cookies.h * @brief The Ewk cookies API. + * + * @note If the libsoup network backend is being used the functions here will + * only work with the @b default SoupSession, which can be retrieved with + * ewk_network_defaul_soup_session_get(). If a different SoupSession is used + * and associated with a view with ewk_view_soup_session_set(), all cookie + * management will have to be done manually. */ #ifndef ewk_cookies_h diff --git a/Source/WebKit/efl/ewk/ewk_frame.cpp b/Source/WebKit/efl/ewk/ewk_frame.cpp index 8dc140150..29fe4f059 100644 --- a/Source/WebKit/efl/ewk/ewk_frame.cpp +++ b/Source/WebKit/efl/ewk/ewk_frame.cpp @@ -1606,7 +1606,6 @@ Eina_Bool ewk_frame_mixed_content_run_get(const Evas_Object* ewkFrame) Ewk_Certificate_Status ewk_frame_certificate_status_get(Evas_Object* ewkFrame) { -#if USE(SOUP) EWK_FRAME_SD_GET_OR_RETURN(ewkFrame, smartData, EWK_CERTIFICATE_STATUS_NO_CERTIFICATE); EINA_SAFETY_ON_NULL_RETURN_VAL(smartData->frame, EWK_CERTIFICATE_STATUS_NO_CERTIFICATE); @@ -1626,9 +1625,6 @@ Ewk_Certificate_Status ewk_frame_certificate_status_get(Evas_Object* ewkFrame) return EWK_CERTIFICATE_STATUS_TRUSTED; return EWK_CERTIFICATE_STATUS_UNTRUSTED; -#endif - - return EWK_CERTIFICATE_STATUS_NO_CERTIFICATE; } /** diff --git a/Source/WebKit/efl/ewk/ewk_main.cpp b/Source/WebKit/efl/ewk/ewk_main.cpp index cead2de72..7621d37d5 100644 --- a/Source/WebKit/efl/ewk/ewk_main.cpp +++ b/Source/WebKit/efl/ewk/ewk_main.cpp @@ -25,8 +25,12 @@ #include "Logging.h" #include "PageCache.h" #include "PageGroup.h" +#include "ResourceHandle.h" #include "ScriptController.h" #include "Settings.h" +#include "StorageTracker.h" +#include "StorageTrackerClientEfl.h" +#include "ewk_auth_soup.h" #include "ewk_logging.h" #include "ewk_network.h" #include "ewk_private.h" @@ -37,21 +41,12 @@ #include <Edje.h> #include <Eina.h> #include <Evas.h> -#include <stdlib.h> -#include <sys/stat.h> -#include <wtf/Threading.h> - -#if ENABLE(GLIB_SUPPORT) #include <glib-object.h> #include <glib.h> -#endif - -#if USE(SOUP) -// REMOVE-ME: see todo below -#include "ResourceHandle.h" -#include "ewk_auth_soup.h" #include <libsoup/soup.h> -#endif +#include <stdlib.h> +#include <sys/stat.h> +#include <wtf/Threading.h> static int _ewkInitCount = 0; @@ -135,16 +130,20 @@ int ewk_shutdown(void) return 0; } +static WebCore::StorageTrackerClientEfl* trackerClient() +{ + DEFINE_STATIC_LOCAL(WebCore::StorageTrackerClientEfl, trackerClient, ()); + return &trackerClient; +} + Eina_Bool _ewk_init_body(void) { -#if ENABLE(GLIB_SUPPORT) g_type_init(); if (!ecore_main_loop_glib_integrate()) WRN("Ecore was not compiled with GLib support, some plugins will not " "work (ie: Adobe Flash)"); -#endif WebCore::ScriptController::initializeThreading(); WebCore::initializeLoggingChannelsIfNecessary(); @@ -174,17 +173,11 @@ Eina_Bool _ewk_init_body(void) ewk_network_tls_certificate_check_set(false); - // TODO: this should move to WebCore, already reported to webkit-gtk folks: -#if USE(SOUP) - if (1) { - SoupSession* session = WebCore::ResourceHandle::defaultSession(); - soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_SNIFFER); - soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER); + WebCore::StorageTracker::initializeTracker(webkitDirectory.utf8().data(), trackerClient()); - SoupSessionFeature* auth_dialog = static_cast<SoupSessionFeature*>(g_object_new(EWK_TYPE_SOUP_AUTH_DIALOG, 0)); - soup_session_add_feature(session, auth_dialog); - } -#endif + SoupSession* session = WebCore::ResourceHandle::defaultSession(); + SoupSessionFeature* auth_dialog = static_cast<SoupSessionFeature*>(g_object_new(EWK_TYPE_SOUP_AUTH_DIALOG, 0)); + soup_session_add_feature(session, auth_dialog); return true; } diff --git a/Source/WebKit/efl/ewk/ewk_network.cpp b/Source/WebKit/efl/ewk/ewk_network.cpp index 0ca5bd1bb..541ccddab 100644 --- a/Source/WebKit/efl/ewk/ewk_network.cpp +++ b/Source/WebKit/efl/ewk/ewk_network.cpp @@ -21,18 +21,14 @@ #include "ewk_network.h" #include "NetworkStateNotifier.h" +#include "ResourceHandle.h" #include "ewk_logging.h" #include <Eina.h> -#include <wtf/text/CString.h> - -#if USE(SOUP) -#include "ResourceHandle.h" #include <libsoup/soup.h> -#endif +#include <wtf/text/CString.h> void ewk_network_proxy_uri_set(const char* proxy) { -#if USE(SOUP) SoupSession* session = WebCore::ResourceHandle::defaultSession(); if (!proxy) { @@ -46,14 +42,10 @@ void ewk_network_proxy_uri_set(const char* proxy) g_object_set(session, SOUP_SESSION_PROXY_URI, uri, NULL); soup_uri_free(uri); -#elif USE(CURL) - EINA_SAFETY_ON_TRUE_RETURN(1); -#endif } const char* ewk_network_proxy_uri_get(void) { -#if USE(SOUP) SoupURI* uri; SoupSession* session = WebCore::ResourceHandle::defaultSession(); g_object_get(session, SOUP_SESSION_PROXY_URI, &uri, NULL); @@ -65,9 +57,6 @@ const char* ewk_network_proxy_uri_get(void) WTF::String proxy = soup_uri_to_string(uri, false); return eina_stringshare_add(proxy.utf8().data()); -#elif USE(CURL) - EINA_SAFETY_ON_TRUE_RETURN_VAL(1, 0); -#endif } void ewk_network_state_notifier_online_set(Eina_Bool online) @@ -79,47 +68,35 @@ Eina_Bool ewk_network_tls_certificate_check_get() { bool checkCertificates = false; -#if USE(SOUP) SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession(); g_object_get(defaultSession, "ssl-strict", &checkCertificates, NULL); -#endif return checkCertificates; } void ewk_network_tls_certificate_check_set(Eina_Bool checkCertificates) { -#if USE(SOUP) SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession(); g_object_set(defaultSession, "ssl-strict", checkCertificates, NULL); -#endif } const char* ewk_network_tls_ca_certificates_path_get() { const char* bundlePath = 0; -#if USE(SOUP) SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession(); g_object_get(defaultSession, "ssl-ca-file", &bundlePath, NULL); -#endif return bundlePath; } void ewk_network_tls_ca_certificates_path_set(const char* bundlePath) { -#if USE(SOUP) SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession(); g_object_set(defaultSession, "ssl-ca-file", bundlePath, NULL); -#endif } SoupSession* ewk_network_default_soup_session_get() { -#if USE(SOUP) return WebCore::ResourceHandle::defaultSession(); -#else - return 0; -#endif } diff --git a/Source/WebKit/efl/ewk/ewk_network.h b/Source/WebKit/efl/ewk/ewk_network.h index 3977e9978..dbec81584 100644 --- a/Source/WebKit/efl/ewk/ewk_network.h +++ b/Source/WebKit/efl/ewk/ewk_network.h @@ -26,17 +26,21 @@ #define ewk_network_h #include <Eina.h> +#include <libsoup/soup-session.h> #ifdef __cplusplus extern "C" { #endif -typedef struct _SoupSession SoupSession; - /** * Sets the given proxy URI to network backend. * * @param proxy URI to set + * + * @note If the libsoup backend is being used, this function has effect on + * the @b default SoupSession, returned by ewk_network_default_soup_session_get(). + * If a different SoupSession is used and passed to ewk_view_soup_session_set(), + * this function will not have any effect on it. */ EAPI void ewk_network_proxy_uri_set(const char *proxy); @@ -46,6 +50,11 @@ EAPI void ewk_network_proxy_uri_set(const char *proxy); * The returned string should be freed by eina_stringshare_del() after use. * * @return current proxy URI or @c 0 if it's not set + * + * @note If the libsoup backend is being used, this function has effect on + * the @b default SoupSession, returned by ewk_network_default_soup_session_get(). + * If a different SoupSession is used and passed to ewk_view_soup_session_set(), + * this function will not have any effect on it. */ EAPI const char *ewk_network_proxy_uri_get(void); @@ -62,6 +71,11 @@ EAPI void ewk_network_state_notifier_online_set(Eina_Bool online); * By default, HTTPS connections are performed regardless of the validity of the certificate provided. * * @sa ewk_network_tls_ca_certificates_path_set + * + * @note If the libsoup backend is being used, this function has effect on + * the @b default SoupSession, returned by ewk_network_default_soup_session_get(). + * If a different SoupSession is used and passed to ewk_view_soup_session_set(), + * this function will not have any effect on it. */ EAPI Eina_Bool ewk_network_tls_certificate_check_get(void); @@ -73,6 +87,11 @@ EAPI Eina_Bool ewk_network_tls_certificate_check_get(void); * @param enable Whether to check the provided certificates or not. * * @sa ewk_network_tls_ca_certificates_path_set + * + * @note If the libsoup backend is being used, this function has effect on + * the @b default SoupSession, returned by ewk_network_default_soup_session_get(). + * If a different SoupSession is used and passed to ewk_view_soup_session_set(), + * this function will not have any effect on it. */ EAPI void ewk_network_tls_certificate_check_set(Eina_Bool enable); @@ -89,6 +108,11 @@ EAPI void ewk_network_tls_certificate_check_set(Eina_Bool enable); * By default, the path is not set, so all certificates are considered as not signed by a trusted root CA. * * @sa ewk_network_tls_certificate_check_set + * + * @note If the libsoup backend is being used, this function has effect on + * the @b default SoupSession, returned by ewk_network_default_soup_session_get(). + * If a different SoupSession is used and passed to ewk_view_soup_session_set(), + * this function will not have any effect on it. */ EAPI const char *ewk_network_tls_ca_certificates_path_get(void); @@ -107,17 +131,18 @@ EAPI const char *ewk_network_tls_ca_certificates_path_get(void); * @param path The path to the certificate bundle. * * @sa ewk_network_tls_certificate_check_set + * + * @note If the libsoup backend is being used, this function has effect on + * the @b default SoupSession, returned by ewk_network_default_soup_session_get(). + * If a different SoupSession is used and passed to ewk_view_soup_session_set(), + * this function will not have any effect on it. */ EAPI void ewk_network_tls_ca_certificates_path_set(const char *path); /** * Returns the default @c SoupSession used by all views. * - * This function is meaningful only if WebKit has been compiled with the - * @c Soup network backend. - * - * @return The default @c SoupSession in use, or @c NULL if another network - * backend was used. + * @return The default @c SoupSession in use. */ EAPI SoupSession *ewk_network_default_soup_session_get(void); diff --git a/Source/WebKit/efl/ewk/ewk_settings.cpp b/Source/WebKit/efl/ewk/ewk_settings.cpp index af561c3b6..d13b39e7e 100644 --- a/Source/WebKit/efl/ewk/ewk_settings.cpp +++ b/Source/WebKit/efl/ewk/ewk_settings.cpp @@ -24,6 +24,7 @@ #include "ApplicationCacheStorage.h" #include "CrossOriginPreflightResultCache.h" #include "DatabaseTracker.h" +#include "StorageTracker.h" #include "FontCache.h" #include "FrameView.h" #include "IconDatabase.h" @@ -57,6 +58,7 @@ static const char* s_offlineAppCachePath = 0; static const char* _ewk_icon_database_path = 0; static const char* s_webDatabasePath = 0; +static const char* s_localStoragePath = 0; static uint64_t s_webDatabaseQuota = 1 * 1024 * 1024; // 1MB. static WTF::String _ewk_settings_webkit_platform_get() @@ -111,6 +113,30 @@ void ewk_settings_web_database_clear() #endif } +void ewk_settings_local_storage_path_set(const char* path) +{ + WebCore::StorageTracker::tracker().setDatabaseDirectoryPath(WTF::String::fromUTF8(path)); + eina_stringshare_replace(&s_localStoragePath, path); +} + +const char* ewk_settings_local_storage_path_get(void) +{ + return s_localStoragePath; +} + +void ewk_settings_local_storage_database_clear() +{ + WebCore::StorageTracker::tracker().deleteAllOrigins(); +} + +void ewk_settings_local_storage_database_origin_clear(const char* url) +{ + EINA_SAFETY_ON_NULL_RETURN(url); + + const WebCore::KURL kurl(WebCore::KURL(), WTF::String::fromUTF8(url)); + WebCore::StorageTracker::tracker().deleteOrigin(WebCore::SecurityOrigin::create(kurl).get()); +} + void ewk_settings_web_database_path_set(const char* path) { #if ENABLE(SQL_DATABASE) diff --git a/Source/WebKit/efl/ewk/ewk_settings.h b/Source/WebKit/efl/ewk/ewk_settings.h index 1e61b4402..cce9a5aa7 100644 --- a/Source/WebKit/efl/ewk/ewk_settings.h +++ b/Source/WebKit/efl/ewk/ewk_settings.h @@ -68,6 +68,53 @@ EAPI void ewk_settings_web_database_clear(void); EAPI void ewk_settings_web_database_path_set(const char *path); /** + * Sets the current path to the directory where WebKit will write the + * HTML5 local storage indexing database (the one keeping track of + * individual views' local storage databases). + * + * By default, the value is @c ~/.webkit + * + * @param path the new local storage database directory path + * + * @note You may want to call + * ewk_view_setting_local_storage_database_path_set() on the same @p + * path, here, for your views. + */ +EAPI void ewk_settings_local_storage_path_set(const char* path); + +/** + * Returns directory's path where the HTML5 local storage indexing + * database is stored. + * + * This is guaranteed to be eina-stringshared, so whenever possible + * save yourself some cpu cycles and use eina_stringshare_ref() + * instead of eina_stringshare_add() or strdup(). + * + * @return database path or @c NULL, on errors. + * + * @see ewk_settings_local_storage_path_set() + */ +EAPI const char* ewk_settings_local_storage_path_get(void); + +/** + * Removes @b all HTML 5 local storage databases. + */ +EAPI void ewk_settings_local_storage_database_clear(); + +/** + * Clears the HTML 5 local storage database for the given URL + * (origin). + * + * @param url which URL to clear local storage to. + * + * After this call, the file holding the local storage database for + * that origin will be deleted, along with its entry on the local + * storage files database (a file stored under the path returned by + * ewk_settings_local_storage_path_get()). + */ +EAPI void ewk_settings_local_storage_database_origin_clear(const char *url); + +/** * Returns directory path where web database is stored. * * By default, the value is @c ~/.webkit diff --git a/Source/WebKit/efl/ewk/ewk_view.cpp b/Source/WebKit/efl/ewk/ewk_view.cpp index 9789c1c30..8a9674022 100644 --- a/Source/WebKit/efl/ewk/ewk_view.cpp +++ b/Source/WebKit/efl/ewk/ewk_view.cpp @@ -1,6 +1,6 @@ /* Copyright (C) 2009-2010 ProFUSION embedded systems - Copyright (C) 2009-2011 Samsung Electronics + Copyright (C) 2009-2012 Samsung Electronics This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public @@ -50,6 +50,7 @@ #include "ProgressTracker.h" #include "RefPtrCairo.h" #include "RenderTheme.h" +#include "ResourceHandle.h" #include "Settings.h" #include "c_instance.h" #include "ewk_logging.h" @@ -59,6 +60,7 @@ #include <Evas.h> #include <eina_safety_checks.h> #include <inttypes.h> +#include <libsoup/soup-session.h> #include <limits> #include <math.h> #include <sys/time.h> @@ -68,6 +70,10 @@ #include "DeviceOrientationClientEfl.h" #endif +#if ENABLE(VIBRATION) +#include "VibrationClientEfl.h" +#endif + static const float zoomMinimum = 0.05; static const float zoomMaximum = 4.0; @@ -211,6 +217,7 @@ struct _Ewk_View_Private_Data { } center; Ecore_Animator* animator; } animatedZoom; + SoupSession* soupSession; }; #ifndef EWK_TYPE_CHECK @@ -604,15 +611,19 @@ static Ewk_View_Private_Data* _ewk_view_priv_new(Ewk_View_Smart_Data* smartData) pageClients.editorClient = new WebCore::EditorClientEfl(smartData->self); pageClients.dragClient = new WebCore::DragClientEfl; pageClients.inspectorClient = new WebCore::InspectorClientEfl; -#if ENABLE(DEVICE_ORIENTATION) - pageClients.deviceMotionClient = new WebCore::DeviceMotionClientEfl; - pageClients.deviceOrientationClient = new WebCore::DeviceOrientationClientEfl; -#endif priv->page = new WebCore::Page(pageClients); if (!priv->page) { CRITICAL("Could not create WebKit Page"); goto error_page; } +#if ENABLE(DEVICE_ORIENTATION) + WebCore::provideDeviceMotionTo(priv->page, new WebCore::DeviceMotionClientEfl); + WebCore::provideDeviceOrientationTo(priv->page, new WebCore::DeviceOrientationClientEfl); +#endif + +#if ENABLE(VIBRATION) + WebCore::provideVibrationTo(priv->page, new WebCore::VibrationClientEfl(smartData->self)); +#endif priv->pageSettings = priv->page->settings(); if (!priv->pageSettings) { @@ -714,6 +725,8 @@ static Ewk_View_Private_Data* _ewk_view_priv_new(Ewk_View_Smart_Data* smartData) goto error_history; } + priv->soupSession = WebCore::ResourceHandle::defaultSession(); + return priv; error_history: @@ -3913,6 +3926,25 @@ Ewk_Page_Visibility_State ewk_view_visibility_state_get(const Evas_Object* ewkVi #endif } +SoupSession* ewk_view_soup_session_get(const Evas_Object* ewkView) +{ + EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, 0); + EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, 0); + return priv->soupSession; +} + +void ewk_view_soup_session_set(Evas_Object* ewkView, SoupSession* session) +{ + EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData); + EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv); + if (!SOUP_IS_SESSION_ASYNC(session)) { + ERR("WebKit requires an SoupSessionAsync to work properly, but " + "a SoupSessionSync was provided."); + return; + } + priv->soupSession = session; +} + namespace EWKPrivate { WebCore::Page *corePage(const Evas_Object *ewkView) diff --git a/Source/WebKit/efl/ewk/ewk_view.h b/Source/WebKit/efl/ewk/ewk_view.h index d3474a64b..7de0e462f 100644 --- a/Source/WebKit/efl/ewk/ewk_view.h +++ b/Source/WebKit/efl/ewk/ewk_view.h @@ -95,6 +95,7 @@ #include <Evas.h> #include <cairo.h> +#include <libsoup/soup-session.h> #ifdef __cplusplus extern "C" { @@ -2335,6 +2336,34 @@ EAPI Eina_Bool ewk_view_mixed_content_displayed_get(const Evas_Object *o); */ EAPI Eina_Bool ewk_view_mixed_content_run_get(const Evas_Object *o); +/** + * Returns the SoupSession associated with this view. + * + * By default, all views share the same, default soup session also available + * by calling ewk_network_default_soup_session_get. + * + * @param o The view to query. + * + * @sa ewk_view_soup_session_set, ewk_network_default_soup_session_get + */ +EAPI SoupSession* ewk_view_soup_session_get(const Evas_Object *o); + +/** + * Associates a new SoupSession with this view. + * + * Only sessions of type SoupSessionAsync are supported. + * + * @note Changing the SoupSession should not be needed in most cases. If + * a different SoupSession is used, the cookie management and some + * network functions in ewk will not have any effect on it. + * + * @param o The view to change. + * @param session The new SoupSession. + * + * @sa ewk_view_soup_session_get, ewk_network_default_soup_session_get + */ +EAPI void ewk_view_soup_session_set(Evas_Object *o, SoupSession *session); + #ifdef __cplusplus } #endif diff --git a/Source/WebKit/gtk/ChangeLog b/Source/WebKit/gtk/ChangeLog index 8c59bb93f..59bb90acb 100644 --- a/Source/WebKit/gtk/ChangeLog +++ b/Source/WebKit/gtk/ChangeLog @@ -1,3 +1,454 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/TextCheckerClientGtk.h: + (WebKit::TextCheckerClientGtk::requestCheckingOfString): + +2012-02-23 ChangSeok Oh <shivamidow@gmail.com> + + [GTK] DRT doesn't support scheduleAsynchronousKeyDown. + https://bugs.webkit.org/show_bug.cgi?id=78481 + + Reviewed by Gustavo Noronha Silva. + + Added a new API to deliver all mutations explicitly. + + * WebCoreSupport/DumpRenderTreeSupportGtk.cpp: + (DumpRenderTreeSupportGtk::deliverAllMutationsIfNecessary): + * WebCoreSupport/DumpRenderTreeSupportGtk.h: + (DumpRenderTreeSupportGtk): + +2012-02-23 Philippe Normand <pnormand@igalia.com> + + [GTK] FullScreen signals + https://bugs.webkit.org/show_bug.cgi?id=76181 + + Reviewed by Martin Robinson. + + Added entering-fullscreen and leaving-fullscreen signals, meant to + be used by the user agent to be notified when an element requests + full screen display and when the full screen display is to be + disabled. + + * WebCoreSupport/ChromeClientGtk.cpp: + (WebKit::ChromeClient::supportsFullScreenForElement): + (WebKit::onFullscreenGtkKeyPressEvent): + (WebKit::ChromeClient::cancelFullScreen): + (WebKit::ChromeClient::enterFullScreenForElement): + (WebKit::ChromeClient::exitFullScreenForElement): + * WebCoreSupport/ChromeClientGtk.h: + * tests/testwebview.c: + * webkit/webkitwebview.cpp: + (webkit_web_view_real_entering_fullscreen): + (webkit_web_view_real_leaving_fullscreen): + (webkit_web_view_class_init): + * webkit/webkitwebview.h: + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientGtk.cpp: + (WebKit::EditorClient::shouldApplyStyle): + * WebCoreSupport/EditorClientGtk.h: + (EditorClient): + +2012-02-22 Philippe Normand <pnormand@igalia.com> + + Unreviewed, rolling out r108522. + http://trac.webkit.org/changeset/108522 + https://bugs.webkit.org/show_bug.cgi?id=76181 + + Broke 4 fullscreen tests on GTK. + + * WebCoreSupport/ChromeClientGtk.cpp: + (WebKit::ChromeClient::supportsFullScreenForElement): + (WebKit::ChromeClient::enterFullScreenForElement): + (WebKit::ChromeClient::exitFullScreenForElement): + * WebCoreSupport/ChromeClientGtk.h: + (ChromeClient): + * tests/testwebview.c: + * webkit/webkitwebview.cpp: + (webkit_web_view_class_init): + * webkit/webkitwebview.h: + (_WebKitWebViewClass): + +2012-02-20 Philippe Normand <pnormand@igalia.com> + + [GTK] FullScreen signals + https://bugs.webkit.org/show_bug.cgi?id=76181 + + Reviewed by Martin Robinson. + + Added entering-fullscreen and leaving-fullscreen signals, meant to + be used by the user agent to be notified when an element requests + full screen display and when the full screen display is to be + disabled. + + * WebCoreSupport/ChromeClientGtk.cpp: + (WebKit::ChromeClient::supportsFullScreenForElement): + (WebKit::onFullscreenGtkKeyPressEvent): + (WebKit::ChromeClient::cancelFullScreen): + (WebKit::ChromeClient::enterFullScreenForElement): + (WebKit::ChromeClient::exitFullScreenForElement): + * WebCoreSupport/ChromeClientGtk.h: + * tests/testwebview.c: + * webkit/webkitwebview.cpp: + (webkit_web_view_real_entering_fullscreen): + (webkit_web_view_real_leaving_fullscreen): + (webkit_web_view_class_init): + * webkit/webkitwebview.h: + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientGtk.cpp: + (WebKit::EditorClient::shouldApplyStyle): + * WebCoreSupport/EditorClientGtk.h: + (EditorClient): + +2012-02-22 Carlos Garcia Campos <cgarcia@igalia.com> + + Unreviewed, rolling out r107351. + http://trac.webkit.org/changeset/107351 + https://bugs.webkit.org/show_bug.cgi?id=53600 + + Several issues introduced in WebKitGTK+ API + + * WebCoreSupport/ChromeClientGtk.cpp: + (WebKit::ChromeClient::ChromeClient): + (WebKit::ChromeClient::chromeDestroyed): + (WebKit::ChromeClient::canRunModal): + (WebKit::ChromeClient::runModal): + * WebCoreSupport/ChromeClientGtk.h: + (ChromeClient): + * webkit/webkitwebview.cpp: + (webkit_web_view_class_init): + +2012-02-21 Philippe Normand <pnormand@igalia.com> + + Fix one more GTK+ unit test after r108278. + + Reviewed by Alejandro G. Castro. + + * tests/testkeyevents.c: + (map_event_cb): No longer grab focus here. + (setup_keyevent_test): Grabbing focus here seems to be late enough in the process. + +2012-02-20 Martin Robinson <mrobinson@igalia.com> + + Fix GTK+ unit tests after r108281. + + Reviewed by Alejandro G. Castro. + + * tests/testwebplugindatabase.c: + (test_webkit_web_plugin_database_get_plugins): Update the description used + in the test. + +2012-02-20 Martin Robinson <mrobinson@igalia.com> + + Fix GTK+ unit tests after r108278. + + Reviewed by Alejandro G. Castro. + + Now that WebCore is no longer stealing focus, we need to + adjust where we grab focus to ensure that it actually succeeds. + + * tests/testcopyandpaste.c: + (map_event_cb): No longer grab focus here. + (runPasteTestCallback): Grabbing focus here seems to be late enough in the process. + +2012-02-20 Martin Robinson <mrobinson@igalia.com> + + [GTK] Web content oftens steals focus from other widgets + https://bugs.webkit.org/show_bug.cgi?id=77791 + + Reviewed by Gustavo Noronha Silva. + + * tests/testwebview.c: Added a WebKit1 test to verify this behavior. + +2012-02-20 Gustavo Noronha Silva <gns@gnome.org> + + [GTK] Needs to claim being a more up-to-date Chrome + https://bugs.webkit.org/show_bug.cgi?id=79044 + + Reviewed by Martin Robinson. + + * webkit/webkitwebsettings.cpp: + (chromeUserAgent): update the version of Chrome we claim to be + to avoid warnings from sites such as Wordpress saying that our + browser is outdated. + +2012-02-19 Paweł Forysiuk <tuxator@o2.pl> + [GTK] Can't find webinspector and error page redirection on Windows + https://bugs.webkit.org/show_bug.cgi?id=51616 + + Use an abstraction for finding shared resources on Windows. + + Reviewed by Martin Robinson. + + * WebCoreSupport/FrameLoaderClientGtk.cpp: + (WebKit::FrameLoaderClient::dispatchDidFailLoad): + * WebCoreSupport/InspectorClientGtk.cpp: + (WebKit::InspectorClient::inspectorFilesPath): + +2012-02-19 Gustavo Noronha Silva <gns@gnome.org> + + Unreviewed. Remove gsettings schema from EXTRA_DIST. + + * GNUmakefile.am: + +2012-02-19 Gustavo Noronha Silva <gns@gnome.org> + + [GTK] Remove unused GSettings stuff + https://bugs.webkit.org/show_bug.cgi?id=78995 + + Reviewed by Martin Robinson. + + * GNUmakefile.am: remove GSettings-related stuff. + * WebCoreSupport/InspectorClientGtk.cpp: + (WebKit): Remove unused code. + * org.webkitgtk.gschema.xml.in: Removed. + * webkit/webkitwebinspector.cpp: + (webkit_web_inspector_execute_script): remove gsettings-related helper. + * webkit/webkitwebinspectorprivate.h: Ditto. + +2012-02-17 Gyuyoung Kim <gyuyoung.kim@samsung.com> + + [GTK] change the way of registering DeviceOrientation clients. + https://bugs.webkit.org/show_bug.cgi?id=78680 + + Reviewed by Gustavo Noronha Silva. + + Bug 78085 removed deviceOrientationClient and deviceMotionClient from PageClients. Instead, + DeviceOrientationClient and DeviceMotionClient should be registered by PageSupplement class. + Chromium, mac and qt ports are already changed by Bug 78085. + + * webkit/webkitwebview.cpp: + (webkit_web_view_init): + +2012-02-16 Martin Robinson <mrobinson@igalia.com> + + [GTK] [AC] Events can starve accelerated compositing updates + https://bugs.webkit.org/show_bug.cgi?id=78826 + + Reviewed by Gustavo Noronha Silva. + + Instead of using a WebCore timer, which can be starved by GdkEvents, + use a raw GLib timer with GDK_PRIORITY_EVENTS to drive AC updates. + This prevents dragging from blocking rendering. + + * WebCoreSupport/AcceleratedCompositingContext.h: + (AcceleratedCompositingContext): Store a GLib source tag instead of a WebCore timer. + * WebCoreSupport/AcceleratedCompositingContextClutter.cpp: + (WebKit::AcceleratedCompositingContext::AcceleratedCompositingContext): + (WebKit::AcceleratedCompositingContext::AcceleratedCompositingContext): + Remove the timer upon destruction. + (WebKit::syncLayersTimeoutCallback): Added this callback for the GLib timer. + (WebKit::AcceleratedCompositingContext::markForSync): Use a GLib timer. + (WebKit::AcceleratedCompositingContext::syncLayersTimeout): Ditto. + * WebCoreSupport/AcceleratedCompositingContextGL.cpp: + (WebKit::AcceleratedCompositingContext::AcceleratedCompositingContext): + (WebKit::AcceleratedCompositingContext::~AcceleratedCompositingContext): + Remove the timer upon destruction. + (WebKit::syncLayersTimeoutCallback): Added this callback for the GLib timer. + (WebKit::AcceleratedCompositingContext::markForSync): Use a GLib timer. + (WebKit::AcceleratedCompositingContext::syncLayersTimeout): Ditto. + +2012-02-16 Adam Barth <abarth@webkit.org> + + Attempt to fix the GTK build. + + * WebCoreSupport/GeolocationClientGtk.cpp: + (WebKit::GeolocationClient::requestPermission): + (WebKit::GeolocationClient::cancelPermissionRequest): + +2012-02-16 Sergio Villar Senin <svillar@igalia.com> + + [soup] Move important SoupSession feature initialization to WebCore + https://bugs.webkit.org/show_bug.cgi?id=68602 + + Reviewed by Martin Robinson. + + Moved content sniffer and decoder initialization from WebKit to + WebCore because network stuff will not work as expected without + them. + + No new tests required as we're just moving stuff from WebKit to + WebCore. + + * webkit/webkitglobals.cpp: + (webkitInit): + +2012-02-16 Philippe Normand <pnormand@igalia.com> + + Unreviewed, rolling out r107941. + http://trac.webkit.org/changeset/107941 + https://bugs.webkit.org/show_bug.cgi?id=68602 + + Broke 23 http tests on GTK + + * webkit/webkitglobals.cpp: + (webkitInit): + +2012-02-16 Sergio Villar Senin <svillar@igalia.com> + + [soup] Move important SoupSession feature initialization to WebCore + https://bugs.webkit.org/show_bug.cgi?id=68602 + + Reviewed by Martin Robinson. + + Moved content sniffer and decoder initialization from WebKit to + WebCore because network stuff will not work as expected without + them. + + No new tests required as we're just moving stuff from WebKit to + WebCore. + + * webkit/webkitglobals.cpp: + (webkitInit): + +2012-01-31 Raphael Kubo da Costa <kubo@profusion.mobi> + + [soup] Add support for multiple SoupSessions. + https://bugs.webkit.org/show_bug.cgi?id=77341 + + Reviewed by Gustavo Noronha Silva. + + Adapt to the changes to FrameNetworkingContext in WebCore. + + * GNUmakefile.am: + * WebCoreSupport/FrameNetworkingContextGtk.cpp: Copied from Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.h. + (WebKit): + (WebKit::FrameNetworkingContextGtk::soupSession): Always return ResourceHandle::defaultSession(). + * WebCoreSupport/FrameNetworkingContextGtk.h: + (FrameNetworkingContextGtk): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebCoreSupport/ChromeClientGtk.h: + (WebKit::ChromeClient::numTouchEventHandlersChanged): + +2012-02-15 No'am Rosenthal <noam.rosenthal@nokia.com> + + [Texmap] Divide TextureMapperNode.cpp to 3 files. + https://bugs.webkit.org/show_bug.cgi?id=76660 + + Rename TextureMapperNode to TextureMapperLayer. + + Reviewed by Kenneth Rohde Christiansen. + + * WebCoreSupport/AcceleratedCompositingContext.h: + (AcceleratedCompositingContext): + * WebCoreSupport/AcceleratedCompositingContextGL.cpp: + (WebKit::AcceleratedCompositingContext::AcceleratedCompositingContext): + (WebKit::AcceleratedCompositingContext::enabled): + (WebKit::AcceleratedCompositingContext::renderLayersToWindow): + (WebKit::AcceleratedCompositingContext::attachRootGraphicsLayer): + (WebKit::AcceleratedCompositingContext::syncLayersTimeout): + +2012-02-11 Nikolas Zimmermann <nzimmermann@rim.com> + + Convert svg/animations to use SMIL methods for driving the timeline + https://bugs.webkit.org/show_bug.cgi?id=78422 + + Reviewed by Dirk Schulze. + + Remove SVG animation sampling functionality provided for DRT, which no longer uses it. + Instead we switched the svg/animations tests to use SVGSVGElement.setCurrentTime. + + * WebCoreSupport/DumpRenderTreeSupportGtk.cpp: + * WebCoreSupport/DumpRenderTreeSupportGtk.h: + (DumpRenderTreeSupportGtk): + +2012-02-13 Mario Sanchez Prada <msanchez@igalia.com> + + [GTK] Add GSList to the list of GObject types in GOwnPtr + https://bugs.webkit.org/show_bug.cgi?id=78487 + + Reviewed by Philippe Normand. + + * WebCoreSupport/ChromeClientGtk.cpp: + (WebKit::ChromeClient::runOpenPanel): Use GOwnPtr<GSList> for the + list of filenames returned by gtk_file_chooser_get_filenames(). + +2012-02-09 Zan Dobersek <zandobersek@gmail.com> + + [GTK] Add DRT support for modal dialogs + https://bugs.webkit.org/show_bug.cgi?id=53600 + + Reviewed by Martin Robinson. + + Add support for running modal dialogs. + + A new signal is added to the WebKitWebView. When emitted, the web view + is requesting to be displayed as a modal dialog. If accepted, the + ChromeClient then establishes a loop that is run until the chrome is destroyed. + If denied, nothing is done. + + * WebCoreSupport/ChromeClientGtk.cpp: + (WebKit::ChromeClient::ChromeClient): + (WebKit::ChromeClient::chromeDestroyed): + (WebKit::ChromeClient::canRunModal): + (WebKit::ChromeClient::runModal): + * WebCoreSupport/ChromeClientGtk.h: + (ChromeClient): + * webkit/webkitwebview.cpp: + (webkit_web_view_class_init): + +2012-02-09 Zan Dobersek <zandobersek@gmail.com> + + [Gtk] security/set-form-autocomplete-attribute.html fails + https://bugs.webkit.org/show_bug.cgi?id=78261 + + Reviewed by Martin Robinson. + + Add a helper function to DumpRenderTreeSupportGtk, returning + whether or not an element does perform autocompletion. + + * WebCoreSupport/DumpRenderTreeSupportGtk.cpp: + (DumpRenderTreeSupportGtk::elementDoesAutoCompleteForElementWithId): + * WebCoreSupport/DumpRenderTreeSupportGtk.h: + (DumpRenderTreeSupportGtk): + +2012-02-09 Martin Robinson <mrobinson@igalia.com> + + Build fix for GTK+ 2.x after my previous commit. + + * webkit/webkitwebview.cpp: + (webkit_web_view_expose_event): The name of the event is expose_event and not expose. + +2012-02-08 Dan Vrátil <dvratil@redhat.com>, Milan Crha <mcrha@redhat.com> + + [GTK] Embedded GtkWidgets are not drawn + https://bugs.webkit.org/show_bug.cgi?id=63451 + + Insert plugin widgets to WebKitWebView container as it's children. + Chain up to parent in webkit_web_view_draw() to ensure the child widgets are drawn. + + Reviewed by Martin Robinson. + + * WebCoreSupport/FrameLoaderClientGtk.cpp: + (WebKit::FrameLoaderClient::createPlugin): + * webkit/webkitwebview.cpp: + (webkit_web_view_draw): + 2012-02-08 Mario Sanchez Prada <msanchez@igalia.com> [Gtk] atk_text_get_text_at_offset() fails to provide the correct line for list items whose text wraps diff --git a/Source/WebKit/gtk/GNUmakefile.am b/Source/WebKit/gtk/GNUmakefile.am index 38d2bb02a..069b5b0a5 100644 --- a/Source/WebKit/gtk/GNUmakefile.am +++ b/Source/WebKit/gtk/GNUmakefile.am @@ -204,6 +204,7 @@ webkitgtk_sources += \ Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.h \ Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp \ Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.h \ + Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.cpp \ Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.h \ Source/WebKit/gtk/WebCoreSupport/FullscreenVideoController.cpp \ Source/WebKit/gtk/WebCoreSupport/FullscreenVideoController.h \ @@ -384,10 +385,6 @@ $(GENSOURCES_WEBKIT)/webkitenumtypes.cpp: $(webkitgtk_h_api) $(WebKit)/GNUmakefi && cp xgen-gtc $@ \ && rm -f xgen-gtc -# GSettings -gsettings_SCHEMAS = $(top_builddir)/Source/WebKit/gtk/org.webkitgtk-@WEBKITGTK_API_VERSION@.gschema.xml -@GSETTINGS_RULES@ - EXTRA_DIST += \ $(WebKit)/ChangeLog \ $(WebKit)/NEWS \ @@ -400,8 +397,7 @@ EXTRA_DIST += \ $(WebKit)/po/* \ $(WebKit)/resources/* \ $(WebKit)/tests/resources/* \ - $(WebKit)/tests/test_utils.h \ - $(WebKit)/org.webkitgtk.gschema.xml.in + $(WebKit)/tests/test_utils.h # extra resource files resourcesdir = ${datadir}/webkitgtk-@WEBKITGTK_API_VERSION@/resources diff --git a/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContext.h b/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContext.h index 42a5f24b6..cad47495d 100644 --- a/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContext.h +++ b/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContext.h @@ -28,7 +28,7 @@ #include <wtf/PassOwnPtr.h> #if USE(TEXTURE_MAPPER_GL) -#include "TextureMapperNode.h" +#include "TextureMapperLayer.h" #include "WindowGLContext.h" #endif @@ -48,7 +48,7 @@ public: void attachRootGraphicsLayer(WebCore::GraphicsLayer*); void scheduleRootLayerRepaint(const WebCore::IntRect&); void markForSync(); - void syncLayersTimeout(WebCore::Timer<AcceleratedCompositingContext>*); + void syncLayersTimeout(); void syncLayersNow(); void resizeRootLayer(const WebCore::IntSize&); bool renderLayersToWindow(const WebCore::IntRect& clipRect); @@ -64,7 +64,7 @@ public: private: WebKitWebView* m_webView; OwnPtr<WebCore::GraphicsLayer> m_rootGraphicsLayer; - WebCore::Timer<AcceleratedCompositingContext> m_syncTimer; + unsigned int m_syncTimerCallbackId; #if USE(CLUTTER) GtkWidget* m_rootLayerEmbedder; @@ -72,7 +72,7 @@ private: void initializeIfNecessary(); bool m_initialized; - WebCore::TextureMapperNode* m_rootTextureMapperNode; + WebCore::TextureMapperLayer* m_rootTextureMapperLayer; OwnPtr<WebCore::WindowGLContext> m_context; OwnPtr<WebCore::TextureMapper> m_textureMapper; #endif diff --git a/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextClutter.cpp b/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextClutter.cpp index b52b409e5..2e95fc56e 100644 --- a/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextClutter.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextClutter.cpp @@ -36,13 +36,15 @@ namespace WebKit { AcceleratedCompositingContext::AcceleratedCompositingContext(WebKitWebView* webView) : m_webView(webView) , m_rootGraphicsLayer(0) - , m_syncTimer(this, &AcceleratedCompositingContext::syncLayersTimeout) + , m_syncTimerCallbackId(0) , m_rootLayerEmbedder(0) { } AcceleratedCompositingContext::~AcceleratedCompositingContext() { + if (m_syncTimerCallbackId) + g_source_remove(m_syncTimerCallbackId); } bool AcceleratedCompositingContext::enabled() @@ -109,14 +111,23 @@ void AcceleratedCompositingContext::resizeRootLayer(const IntSize& size) gtk_widget_size_allocate(GTK_WIDGET(m_webView->priv->rootLayerEmbedder), &allocation); } +static gboolean syncLayersTimeoutCallback(AcceleratedCompositingContext* context) +{ + context->syncLayersTimeout(); + return FALSE; +} + void AcceleratedCompositingContext::markForSync() { - if (m_syncTimer.isActive()) + if (m_syncTimerCallbackId) return; - m_syncTimer.startOneShot(0); + + // We use a GLib timer because otherwise GTK+ event handling during + // dragging can starve WebCore timers, which have a lower priority. + m_syncTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, 0, reinterpret_cast<GSourceFunc>(syncLayersTimeoutCallback), this, 0); } -void AcceleratedCompositingContext::syncLayersTimeout(Timer<AcceleratedCompositingContext>*) +void AcceleratedCompositingContext::syncLayersTimeout() { core(m_webView)->mainFrame()->view()->syncCompositingStateIncludingSubframes(); } diff --git a/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextGL.cpp b/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextGL.cpp index 9bfa3d0fe..8c4300f27 100644 --- a/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextGL.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextGL.cpp @@ -28,7 +28,7 @@ #include "FrameView.h" #include "PlatformContextCairo.h" #include "TextureMapperGL.h" -#include "TextureMapperNode.h" +#include "TextureMapperLayer.h" #include "webkitwebviewprivate.h" #include <GL/gl.h> #include <cairo.h> @@ -41,15 +41,16 @@ namespace WebKit { AcceleratedCompositingContext::AcceleratedCompositingContext(WebKitWebView* webView) : m_webView(webView) - , m_syncTimer(this, &AcceleratedCompositingContext::syncLayersTimeout) + , m_syncTimerCallbackId(0) , m_initialized(false) - , m_rootTextureMapperNode(0) + , m_rootTextureMapperLayer(0) { } AcceleratedCompositingContext::~AcceleratedCompositingContext() { - + if (m_syncTimerCallbackId) + g_source_remove(m_syncTimerCallbackId); } void AcceleratedCompositingContext::initializeIfNecessary() @@ -69,7 +70,7 @@ void AcceleratedCompositingContext::initializeIfNecessary() bool AcceleratedCompositingContext::enabled() { - return m_rootTextureMapperNode && m_textureMapper; + return m_rootTextureMapperLayer && m_textureMapper; } @@ -90,7 +91,7 @@ bool AcceleratedCompositingContext::renderLayersToWindow(const IntRect& clipRect glViewport(0, 0, allocation.width, allocation.height); m_textureMapper->beginPainting(); - m_rootTextureMapperNode->paint(); + m_rootTextureMapperLayer->paint(); m_textureMapper->endPainting(); m_context->finishDrawing(); @@ -101,12 +102,12 @@ void AcceleratedCompositingContext::attachRootGraphicsLayer(GraphicsLayer* graph { if (!graphicsLayer) { m_rootGraphicsLayer.clear(); - m_rootTextureMapperNode = 0; + m_rootTextureMapperLayer = 0; return; } m_rootGraphicsLayer = GraphicsLayer::create(this); - m_rootTextureMapperNode = toTextureMapperNode(m_rootGraphicsLayer.get()); + m_rootTextureMapperLayer = toTextureMapperLayer(m_rootGraphicsLayer.get()); m_rootGraphicsLayer->addChild(graphicsLayer); m_rootGraphicsLayer->setDrawsContent(true); m_rootGraphicsLayer->setMasksToBounds(false); @@ -127,7 +128,7 @@ void AcceleratedCompositingContext::attachRootGraphicsLayer(GraphicsLayer* graph glViewport(0, 0, allocation.width, allocation.height); m_textureMapper = TextureMapperGL::create(); - m_rootTextureMapperNode->setTextureMapper(m_textureMapper.get()); + m_rootTextureMapperLayer->setTextureMapper(m_textureMapper.get()); m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly(); } @@ -150,11 +151,20 @@ void AcceleratedCompositingContext::resizeRootLayer(const IntSize& size) m_rootGraphicsLayer->setNeedsDisplay(); } +static gboolean syncLayersTimeoutCallback(AcceleratedCompositingContext* context) +{ + context->syncLayersTimeout(); + return FALSE; +} + void AcceleratedCompositingContext::markForSync() { - if (m_syncTimer.isActive()) + if (m_syncTimerCallbackId) return; - m_syncTimer.startOneShot(0); + + // We use a GLib timer because otherwise GTK+ event handling during + // dragging can starve WebCore timers, which have a lower priority. + m_syncTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, 0, reinterpret_cast<GSourceFunc>(syncLayersTimeoutCallback), this, 0); } void AcceleratedCompositingContext::syncLayersNow() @@ -165,16 +175,17 @@ void AcceleratedCompositingContext::syncLayersNow() core(m_webView)->mainFrame()->view()->syncCompositingStateIncludingSubframes(); } -void AcceleratedCompositingContext::syncLayersTimeout(Timer<AcceleratedCompositingContext>*) +void AcceleratedCompositingContext::syncLayersTimeout() { + m_syncTimerCallbackId = 0; syncLayersNow(); if (!m_rootGraphicsLayer) return; renderLayersToWindow(IntRect()); - if (toTextureMapperNode(m_rootGraphicsLayer.get())->descendantsOrSelfHaveRunningAnimations()) - m_syncTimer.startOneShot(1.0 / 60.0); + if (toTextureMapperLayer(m_rootGraphicsLayer.get())->descendantsOrSelfHaveRunningAnimations()) + m_syncTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, 1000.0 / 60.0, reinterpret_cast<GSourceFunc>(syncLayersTimeoutCallback), this, 0); } void AcceleratedCompositingContext::notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) diff --git a/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp index 955c166a9..d282f290a 100644 --- a/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp @@ -51,6 +51,8 @@ #include "RefPtrCairo.h" #include "SearchPopupMenuGtk.h" #include "SecurityOrigin.h" +#include "WebKitDOMBinding.h" +#include "WebKitDOMHTMLElementPrivate.h" #include "WindowFeatures.h" #include "webkitgeolocationpolicydecision.h" #include "webkitgeolocationpolicydecisionprivate.h" @@ -61,6 +63,8 @@ #include "webkitwebview.h" #include "webkitwebviewprivate.h" #include "webkitwebwindowfeaturesprivate.h" +#include <gdk/gdk.h> +#include <gdk/gdkkeysyms.h> #include <glib.h> #include <glib/gi18n-lib.h> #include <gtk/gtk.h> @@ -807,15 +811,14 @@ void ChromeClient::runOpenPanel(Frame*, PassRefPtr<FileChooser> prpFileChooser) if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { if (gtk_file_chooser_get_select_multiple(GTK_FILE_CHOOSER(dialog))) { - GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); + GOwnPtr<GSList> filenames(gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog))); Vector<String> names; - for (GSList* item = filenames ; item ; item = item->next) { + for (GSList* item = filenames.get() ; item ; item = item->next) { if (!item->data) continue; names.append(filenameToString(static_cast<char*>(item->data))); g_free(item->data); } - g_slist_free(filenames); chooser->chooseFiles(names); } else { gchar* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); @@ -922,29 +925,69 @@ void ChromeClient::exitFullscreenForNode(Node* node) #if ENABLE(FULLSCREEN_API) bool ChromeClient::supportsFullScreenForElement(const WebCore::Element* element, bool withKeyboard) { - return true; + return !withKeyboard; +} + +static gboolean onFullscreenGtkKeyPressEvent(GtkWidget* widget, GdkEventKey* event, ChromeClient* chromeClient) +{ + switch (event->keyval) { + case GDK_KEY_Escape: + case GDK_KEY_f: + case GDK_KEY_F: + chromeClient->cancelFullScreen(); + return TRUE; + default: + break; + } + + return FALSE; +} + +void ChromeClient::cancelFullScreen() +{ + ASSERT(m_fullScreenElement); + m_fullScreenElement->document()->webkitCancelFullScreen(); } void ChromeClient::enterFullScreenForElement(WebCore::Element* element) { + gboolean returnValue; + GRefPtr<WebKitDOMHTMLElement> kitElement(adoptGRef(kit(reinterpret_cast<HTMLElement*>(element)))); + g_signal_emit_by_name(m_webView, "entering-fullscreen", kitElement.get(), &returnValue); + if (returnValue) + return; + + GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView)); + if (!widgetIsOnscreenToplevelWindow(window)) + return; + + g_signal_connect(window, "key-press-event", G_CALLBACK(onFullscreenGtkKeyPressEvent), this); + + m_fullScreenElement = element; + element->document()->webkitWillEnterFullScreenForElement(element); m_adjustmentWatcher.disableAllScrollbars(); -#if ENABLE(VIDEO) - if (element->tagName() == "VIDEO") - enterFullscreenForNode(static_cast<Node*>(element)); -#endif + gtk_window_fullscreen(GTK_WINDOW(window)); element->document()->webkitDidEnterFullScreenForElement(element); } void ChromeClient::exitFullScreenForElement(WebCore::Element* element) { + gboolean returnValue; + GRefPtr<WebKitDOMHTMLElement> kitElement(adoptGRef(kit(reinterpret_cast<HTMLElement*>(element)))); + g_signal_emit_by_name(m_webView, "leaving-fullscreen", kitElement.get(), &returnValue); + if (returnValue) + return; + + GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView)); + ASSERT(widgetIsOnscreenToplevelWindow(window)); + g_signal_handlers_disconnect_by_func(window, reinterpret_cast<void*>(onFullscreenGtkKeyPressEvent), this); + element->document()->webkitWillExitFullScreenForElement(element); + gtk_window_unfullscreen(GTK_WINDOW(window)); m_adjustmentWatcher.enableAllScrollbars(); -#if ENABLE(VIDEO) - if (element->tagName() == "VIDEO") - webViewExitFullscreen(m_webView); -#endif element->document()->webkitDidExitFullScreenForElement(element); + m_fullScreenElement.clear(); } #endif diff --git a/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h b/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h index 8c7c89233..5905f5679 100644 --- a/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h +++ b/Source/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h @@ -155,10 +155,12 @@ namespace WebKit { virtual bool supportsFullScreenForElement(const Element*, bool withKeyboard); virtual void enterFullScreenForElement(Element*); virtual void exitFullScreenForElement(Element*); + void cancelFullScreen(); #endif virtual bool shouldRubberBandInDirection(ScrollDirection) const { return true; } virtual void numWheelEventHandlersChanged(unsigned) { } + virtual void numTouchEventHandlersChanged(unsigned) { } #if USE(ACCELERATED_COMPOSITING) virtual void attachRootGraphicsLayer(Frame*, GraphicsLayer*); @@ -185,6 +187,9 @@ namespace WebKit { unsigned int m_repaintSoonSourceId; void invalidateWidgetRect(const IntRect&); +#if ENABLE(FULLSCREEN_API) + RefPtr<Element> m_fullScreenElement; +#endif }; } diff --git a/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.cpp index c59e1f792..8e6e26b14 100644 --- a/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.cpp @@ -61,6 +61,7 @@ #include "TextIterator.h" #include "WebKitAccessibleWrapperAtk.h" #include "WebKitDOMRangePrivate.h" +#include "WebKitMutationObserver.h" #include "WorkerThread.h" #include "webkitglobalsprivate.h" #include "webkitwebframe.h" @@ -69,11 +70,6 @@ #include "webkitwebviewprivate.h" #include <JavaScriptCore/APICast.h> -#if ENABLE(SVG) -#include "SVGDocumentExtensions.h" -#include "SVGSMILElement.h" -#endif - using namespace JSC; using namespace WebCore; using namespace WebKit; @@ -395,22 +391,6 @@ bool DumpRenderTreeSupportGtk::pauseTransition(WebKitWebFrame* frame, const char return core(frame)->animation()->pauseTransitionAtTime(coreElement->renderer(), AtomicString(name), time); } -bool DumpRenderTreeSupportGtk::pauseSVGAnimation(WebKitWebFrame* frame, const char* animationId, double time, const char* elementId) -{ - ASSERT(core(frame)); -#if ENABLE(SVG) - Document* document = core(frame)->document(); - if (!document || !document->svgExtensions()) - return false; - Element* coreElement = document->getElementById(AtomicString(animationId)); - if (!coreElement || !SVGSMILElement::isSMILElement(coreElement)) - return false; - return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreElement), time); -#else - return false; -#endif -} - CString DumpRenderTreeSupportGtk::markerTextForListItem(WebKitWebFrame* frame, JSContextRef context, JSValueRef nodeObject) { JSC::ExecState* exec = toJS(context); @@ -913,3 +893,33 @@ void DumpRenderTreeSupportGtk::setHixie76WebSocketProtocolEnabled(WebKitWebView* UNUSED_PARAM(enabled); #endif } + +bool DumpRenderTreeSupportGtk::elementDoesAutoCompleteForElementWithId(WebKitWebFrame* frame, JSStringRef id) +{ + Frame* coreFrame = core(frame); + if (!coreFrame) + return false; + + Document* document = coreFrame->document(); + ASSERT(document); + + size_t bufferSize = JSStringGetMaximumUTF8CStringSize(id); + GOwnPtr<gchar> idBuffer(static_cast<gchar*>(g_malloc(bufferSize))); + JSStringGetUTF8CString(id, idBuffer.get(), bufferSize); + Node* coreNode = document->getElementById(String::fromUTF8(idBuffer.get())); + if (!coreNode || !coreNode->renderer()) + return false; + + HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(coreNode); + if (!inputElement) + return false; + + return inputElement->isTextField() && !inputElement->isPasswordField() && inputElement->shouldAutocomplete(); +} + +void DumpRenderTreeSupportGtk::deliverAllMutationsIfNecessary() +{ +#if ENABLE(MUTATION_OBSERVERS) + WebKitMutationObserver::deliverAllMutations(); +#endif +} diff --git a/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.h b/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.h index 06d30070a..02b80c476 100644 --- a/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.h +++ b/Source/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.h @@ -75,7 +75,6 @@ public: static guint getPendingUnloadEventCount(WebKitWebFrame*); static bool pauseAnimation(WebKitWebFrame*, const char* name, double time, const char* element); static bool pauseTransition(WebKitWebFrame*, const char* name, double time, const char* element); - static bool pauseSVGAnimation(WebKitWebFrame*, const char* animationId, double time, const char* elementId); static WTF::CString markerTextForListItem(WebKitWebFrame*, JSContextRef, JSValueRef nodeObject); static unsigned int numberOfActiveAnimations(WebKitWebFrame*); static void suspendAnimations(WebKitWebFrame*); @@ -87,6 +86,7 @@ public: static void setAutofilled(JSContextRef, JSValueRef, bool); static void setValueForUser(JSContextRef, JSValueRef, JSStringRef); static bool shouldClose(WebKitWebFrame*); + static bool elementDoesAutoCompleteForElementWithId(WebKitWebFrame*, JSStringRef); // WebKitWebView static void executeCoreCommandByName(WebKitWebView*, const gchar* name, const gchar* value); @@ -129,6 +129,8 @@ public: static void setHixie76WebSocketProtocolEnabled(WebKitWebView*, bool enabled); + static void deliverAllMutationsIfNecessary(); + private: static bool s_drtRun; static bool s_linksIncludedInTabChain; diff --git a/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp index 913b0df8e..b8e160e28 100644 --- a/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp @@ -235,10 +235,10 @@ bool EditorClient::shouldChangeSelectedRange(Range* fromRange, Range* toRange, E return accept; } -bool EditorClient::shouldApplyStyle(WebCore::CSSStyleDeclaration* declaration, WebCore::Range* range) +bool EditorClient::shouldApplyStyle(WebCore::StylePropertySet* set, WebCore::Range* range) { gboolean accept = TRUE; - GRefPtr<WebKitDOMCSSStyleDeclaration> kitDeclaration(kit(declaration)); + GRefPtr<WebKitDOMCSSStyleDeclaration> kitDeclaration(kit(set->ensureCSSStyleDeclaration())); GRefPtr<WebKitDOMRange> kitRange(adoptGRef(kit(range))); g_signal_emit_by_name(m_webView, "should-apply-style", kitDeclaration.get(), kitRange.get(), &accept); return accept; diff --git a/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.h b/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.h index 2533c1644..ef159c646 100644 --- a/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.h +++ b/Source/WebKit/gtk/WebCoreSupport/EditorClientGtk.h @@ -94,7 +94,7 @@ class EditorClient : public WebCore::EditorClient { virtual bool shouldInsertText(const WTF::String&, WebCore::Range*, WebCore::EditorInsertAction); virtual bool shouldChangeSelectedRange(WebCore::Range* fromRange, WebCore::Range* toRange, WebCore::EAffinity, bool stillSelecting); - virtual bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*); + virtual bool shouldApplyStyle(WebCore::StylePropertySet*, WebCore::Range*); virtual bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*); diff --git a/Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp index 60b00e893..42a494583 100644 --- a/Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp @@ -33,6 +33,7 @@ #include "DocumentLoader.h" #include "DocumentLoaderGtk.h" #include "ErrorsGtk.h" +#include "FileSystem.h" #include "FormState.h" #include "FrameLoader.h" #include "FrameNetworkingContextGtk.h" @@ -482,8 +483,10 @@ PassRefPtr<Widget> FrameLoaderClient::createPlugin(const IntSize& pluginSize, HT GtkWidget* gtkWidget = 0; g_signal_emit_by_name(getViewFromFrame(m_frame), "create-plugin-widget", mimeTypeString.data(), urlString.data(), hash.get(), >kWidget); - if (gtkWidget) + if (gtkWidget) { + gtk_container_add(GTK_CONTAINER(getViewFromFrame(m_frame)), gtkWidget); return adoptRef(new GtkPluginWidget(gtkWidget)); + } RefPtr<PluginView> pluginView = PluginView::create(core(m_frame), pluginSize, element, url, paramNames, paramValues, mimeType, loadManually); @@ -1103,7 +1106,9 @@ void FrameLoaderClient::dispatchDidFailLoad(const ResourceError& error) String content; gchar* fileContent = 0; - gchar* errorURI = g_filename_to_uri(DATA_DIR"/webkit-1.0/resources/error.html", NULL, NULL); + GOwnPtr<gchar> errorPath(g_build_filename(sharedResourcesPath().data(), "resources", "error.html", NULL)); + gchar* errorURI = g_filename_to_uri(errorPath.get(), 0, 0); + GFile* errorFile = g_file_new_for_uri(errorURI); g_free(errorURI); diff --git a/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.cpp new file mode 100644 index 000000000..4b9d12491 --- /dev/null +++ b/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.cpp @@ -0,0 +1,35 @@ +/* + Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) + Copyright (C) 2012 ProFUSION embedded systems + + 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 "FrameNetworkingContextGtk.h" + +#include "ResourceHandle.h" + +using namespace WebCore; + +namespace WebKit { + +SoupSession* FrameNetworkingContextGtk::soupSession() const +{ + return ResourceHandle::defaultSession(); +} + +} diff --git a/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.h b/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.h index 8e4c2148d..a59a94099 100644 --- a/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.h +++ b/Source/WebKit/gtk/WebCoreSupport/FrameNetworkingContextGtk.h @@ -32,6 +32,7 @@ public: } WebCore::Frame* coreFrame() const { return frame(); } + virtual SoupSession* soupSession() const; private: FrameNetworkingContextGtk(WebCore::Frame* frame) diff --git a/Source/WebKit/gtk/WebCoreSupport/GeolocationClientGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/GeolocationClientGtk.cpp index fac1d73af..06e9fbd3f 100644 --- a/Source/WebKit/gtk/WebCoreSupport/GeolocationClientGtk.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/GeolocationClientGtk.cpp @@ -24,6 +24,7 @@ #if ENABLE(CLIENT_BASED_GEOLOCATION) #include "Chrome.h" +#include "ChromeClient.h" #include "Geolocation.h" #include "GeolocationController.h" #include "GeolocationError.h" @@ -137,12 +138,12 @@ WebCore::GeolocationPosition* GeolocationClient::lastPosition() void GeolocationClient::requestPermission(WebCore::Geolocation* geolocation) { - core(m_webView)->chrome()->requestGeolocationPermissionForFrame(geolocation->frame(), geolocation); + core(m_webView)->chrome()->client()->requestGeolocationPermissionForFrame(geolocation->frame(), geolocation); } void GeolocationClient::cancelPermissionRequest(WebCore::Geolocation* geolocation) { - core(m_webView)->chrome()->cancelGeolocationPermissionRequestForFrame(geolocation->frame(), geolocation); + core(m_webView)->chrome()->client()->cancelGeolocationPermissionRequestForFrame(geolocation->frame(), geolocation); } void GeolocationClient::positionChanged(GeocluePosition*, GeocluePositionFields fields, int timestamp, double latitude, double longitude, double altitude, GeoclueAccuracy* accuracy) diff --git a/Source/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp b/Source/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp index d4d321d93..c1dd9b911 100644 --- a/Source/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp +++ b/Source/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp @@ -20,6 +20,7 @@ #include "config.h" #include "InspectorClientGtk.h" +#include "FileSystem.h" #include "Frame.h" #include "InspectorController.h" #include "NotImplemented.h" @@ -48,55 +49,16 @@ public: virtual ~InspectorFrontendSettingsGtk() { } private: -#ifdef HAVE_GSETTINGS - static bool shouldIgnoreSetting(const String& key) - { - // GSettings considers trying to fetch or set a setting that is - // not backed by a schema as programmer error, and aborts the - // program's execution. We check here to avoid having an unhandled - // setting as a fatal error. - LOG_VERBOSE(NotYetImplemented, "Unknown key ignored: %s", key.ascii().data()); - return true; - } - virtual String getProperty(const String& name) { - if (shouldIgnoreSetting(name)) - return String(); - - GSettings* settings = inspectorGSettings(); - if (!settings) - return String(); - - GRefPtr<GVariant> variant = adoptGRef(g_settings_get_value(settings, name.utf8().data())); - return String(g_variant_get_string(variant.get(), 0)); - } - - virtual void setProperty(const String& name, const String& value) - { - // Avoid setting unknown keys to avoid aborting the execution. - if (shouldIgnoreSetting(name)) - return; - - GSettings* settings = inspectorGSettings(); - if (!settings) - return; - - GRefPtr<GVariant> variant = adoptGRef(g_variant_new_string(value.utf8().data())); - g_settings_set_value(settings, name.utf8().data(), variant.get()); - } -#else - virtual String getProperty(const String&) - { notImplemented(); return String(); } - virtual void setProperty(const String&, const String&) + virtual void setProperty(const String& name, const String& value) { notImplemented(); } -#endif // HAVE_GSETTINGS }; } // namespace @@ -202,7 +164,7 @@ const char* InspectorClient::inspectorFilesPath() if (environmentPath && g_file_test(environmentPath, G_FILE_TEST_IS_DIR)) m_inspectorFilesPath.set(g_strdup(environmentPath)); else - m_inspectorFilesPath.set(g_build_filename(DATA_DIR, "webkitgtk-"WEBKITGTK_API_VERSION_STRING, "webinspector", NULL)); + m_inspectorFilesPath.set(g_build_filename(sharedResourcesPath().data(), "webinspector", NULL)); return m_inspectorFilesPath.get(); } diff --git a/Source/WebKit/gtk/WebCoreSupport/TextCheckerClientGtk.h b/Source/WebKit/gtk/WebCoreSupport/TextCheckerClientGtk.h index e5390bcc9..b3fa04994 100644 --- a/Source/WebKit/gtk/WebCoreSupport/TextCheckerClientGtk.h +++ b/Source/WebKit/gtk/WebCoreSupport/TextCheckerClientGtk.h @@ -48,7 +48,7 @@ class TextCheckerClientGtk : public WebCore::TextCheckerClient { virtual WTF::String getAutoCorrectSuggestionForMisspelledWord(const WTF::String&); virtual void checkGrammarOfString(const UChar*, int length, WTF::Vector<WebCore::GrammarDetail>&, int* badGrammarLocation, int* badGrammarLength); virtual void getGuessesForWord(const WTF::String& word, const WTF::String& context, WTF::Vector<WTF::String>& guesses); - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&) {} + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&) { } void updateSpellCheckingLanguage(const char*); private: diff --git a/Source/WebKit/gtk/org.webkitgtk.gschema.xml.in b/Source/WebKit/gtk/org.webkitgtk.gschema.xml.in deleted file mode 100644 index 17063f4b8..000000000 --- a/Source/WebKit/gtk/org.webkitgtk.gschema.xml.in +++ /dev/null @@ -1,32 +0,0 @@ -<schemalist> - <schema id="org.webkitgtk-@WEBKITGTK_API_VERSION@" path="/system/webkitgtk/"> - <child schema="org.webkitgtk-@WEBKITGTK_API_VERSION@.inspector" name="inspector"/> - </schema> - <schema id="org.webkitgtk-@WEBKITGTK_API_VERSION@.inspector" path="/system/webkitgtk/inspector/"> - <key name="resource-tracking-enabled" type="b"> - <default>false</default> - <summary>Resource Tracking Enabled</summary> - <description>Whether the Resource Tracking panel is always enabled.</description> - </key> - <key name="xhr-monitor-enabled" type="b"> - <default>false</default> - <summary>XHR Monitor Enabled</summary> - <description>Whether the XHR monitor is always enabled.</description> - </key> - <key name="debugger-enabled" type="b"> - <default>false</default> - <summary>Debugger Enabled</summary> - <description>Whether the debugger is always enabled.</description> - </key> - <key name="profiler-enabled" type="b"> - <default>false</default> - <summary>Profiler Enabled</summary> - <description>Whether the profiler is always enabled.</description> - </key> - <key name="frontend-settings" type="s"> - <default>''</default> - <summary>Misc Inspector Frontend Settings</summary> - <description>Miscelaneous Settings managed by the Inspector Frontend</description> - </key> - </schema> -</schemalist> diff --git a/Source/WebKit/gtk/tests/testcopyandpaste.c b/Source/WebKit/gtk/tests/testcopyandpaste.c index 6d1b48080..7d8dd8f0d 100644 --- a/Source/WebKit/gtk/tests/testcopyandpaste.c +++ b/Source/WebKit/gtk/tests/testcopyandpaste.c @@ -111,7 +111,6 @@ static void load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer da gboolean map_event_cb(GtkWidget *widget, GdkEvent* event, gpointer data) { - gtk_widget_grab_focus(widget); CopyAndPasteFixture* fixture = (CopyAndPasteFixture*)data; webkit_web_view_load_string(fixture->webView, fixture->info->page, "text/html", "utf-8", "file://"); @@ -137,6 +136,8 @@ static void test_copy_and_paste(CopyAndPasteFixture* fixture, gconstpointer data static CopyAndPasteFixture* currentFixture; static JSValueRef runPasteTestCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { + gtk_widget_grab_focus(GTK_WIDGET(currentFixture->webView)); + // Simulate a paste keyboard sequence. GdkEvent* event = gdk_event_new(GDK_KEY_PRESS); event->key.keyval = gdk_unicode_to_keyval('v'); diff --git a/Source/WebKit/gtk/tests/testkeyevents.c b/Source/WebKit/gtk/tests/testkeyevents.c index cf33d4abe..b55b4bcaf 100644 --- a/Source/WebKit/gtk/tests/testkeyevents.c +++ b/Source/WebKit/gtk/tests/testkeyevents.c @@ -118,7 +118,6 @@ static void test_keypress_events_load_status_cb(WebKitWebView* webView, GParamSp gboolean map_event_cb(GtkWidget *widget, GdkEvent* event, gpointer data) { - gtk_widget_grab_focus(widget); KeyEventFixture* fixture = (KeyEventFixture*)data; webkit_web_view_load_string(fixture->webView, fixture->info->page, "text/html", "utf-8", "file://"); @@ -131,6 +130,7 @@ static void setup_keyevent_test(KeyEventFixture* fixture, gconstpointer data, GC g_signal_connect(fixture->window, "map-event", G_CALLBACK(map_event_cb), fixture); + gtk_widget_grab_focus(GTK_WIDGET(fixture->webView)); gtk_widget_show(fixture->window); gtk_widget_show(GTK_WIDGET(fixture->webView)); gtk_window_present(GTK_WINDOW(fixture->window)); diff --git a/Source/WebKit/gtk/tests/testwebplugindatabase.c b/Source/WebKit/gtk/tests/testwebplugindatabase.c index db2529f3a..f5e23d08a 100644 --- a/Source/WebKit/gtk/tests/testwebplugindatabase.c +++ b/Source/WebKit/gtk/tests/testwebplugindatabase.c @@ -44,7 +44,7 @@ static void test_webkit_web_plugin_database_get_plugins() for (p = pluginList; p; p = p->next) { WebKitWebPlugin* plugin = (WebKitWebPlugin*)p->data; if (!g_strcmp0(webkit_web_plugin_get_name(plugin), "WebKit Test PlugIn") && - !g_strcmp0(webkit_web_plugin_get_description(plugin), "Simple Netscape plug-in that handles test content for WebKit")) { + !g_strcmp0(webkit_web_plugin_get_description(plugin), "Simple Netscape® plug-in that handles test content for WebKit")) { found = TRUE; enabled = webkit_web_plugin_get_enabled(plugin); webkit_web_plugin_set_enabled(plugin, FALSE); @@ -60,7 +60,7 @@ static void test_webkit_web_plugin_database_get_plugins() for (p = pluginList; p; p = p->next) { WebKitWebPlugin* plugin = (WebKitWebPlugin*)p->data; if (!g_strcmp0(webkit_web_plugin_get_name(plugin), "WebKit Test PlugIn") && - !g_strcmp0(webkit_web_plugin_get_description(plugin), "Simple Netscape plug-in that handles test content for WebKit")) + !g_strcmp0(webkit_web_plugin_get_description(plugin), "Simple Netscape® plug-in that handles test content for WebKit")) enabled = webkit_web_plugin_get_enabled(plugin); } webkit_web_plugin_database_plugins_list_free(pluginList); diff --git a/Source/WebKit/gtk/tests/testwebview.c b/Source/WebKit/gtk/tests/testwebview.c index 41cf308f6..ab3bd5576 100644 --- a/Source/WebKit/gtk/tests/testwebview.c +++ b/Source/WebKit/gtk/tests/testwebview.c @@ -382,6 +382,121 @@ static void test_webkit_web_view_in_offscreen_window_does_not_crash() g_main_loop_unref(loop); } +static void test_webkit_web_view_does_not_steal_focus() +{ + loop = g_main_loop_new(NULL, TRUE); + + GtkWidget *window = gtk_offscreen_window_new(); + GtkWidget *webView = webkit_web_view_new(); + GtkWidget *entry = gtk_entry_new(); + GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); + + gtk_container_add(GTK_CONTAINER(box), webView); + gtk_container_add(GTK_CONTAINER(box), entry); + gtk_container_add(GTK_CONTAINER(window), box); + gtk_widget_show_all(window); + + gtk_widget_grab_focus(entry); + g_assert(gtk_widget_is_focus(entry)); + + g_signal_connect(webView, "notify::load-status", G_CALLBACK(idle_quit_loop_cb), NULL); + webkit_web_view_load_html_string(WEBKIT_WEB_VIEW(webView), + "<html><body>" + " <input id=\"entry\" type=\"text\"/>" + " <script>" + " document.getElementById(\"entry\").focus();" + " </script>" + "</body></html>", "file://"); + + g_main_loop_run(loop); + + g_assert(gtk_widget_is_focus(entry)); + + gtk_widget_destroy(window); + g_main_loop_unref(loop); +} + +static gboolean emitKeyStroke(WebKitWebView* webView) +{ + GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS); + pressEvent->key.keyval = GDK_KEY_f; + GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(webView)); + pressEvent->key.window = window; + g_object_ref(pressEvent->key.window); + + GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(window)); + gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(manager)); + + // When synthesizing an event, an invalid hardware_keycode value + // can cause it to be badly processed by Gtk+. + GdkKeymapKey* keys; + gint n_keys; + if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), GDK_KEY_f, &keys, &n_keys)) { + pressEvent->key.hardware_keycode = keys[0].keycode; + g_free(keys); + } + + GdkEvent* releaseEvent = gdk_event_copy(pressEvent); + gtk_main_do_event(pressEvent); + gdk_event_free(pressEvent); + releaseEvent->key.type = GDK_KEY_RELEASE; + gtk_main_do_event(releaseEvent); + gdk_event_free(releaseEvent); + + return FALSE; +} + +static gboolean entering_fullscreen_cb(WebKitWebView* webView, GObject* element, gboolean blocked) +{ + if (blocked) + g_main_loop_quit(loop); + else + g_timeout_add(200, (GSourceFunc) emitKeyStroke, webView); + return blocked; +} + +static gboolean leaving_fullscreen_cb(WebKitWebView* webView, GObject* element, gpointer data) +{ + g_main_loop_quit(loop); + return FALSE; +} + +static void test_webkit_web_view_fullscreen(gconstpointer blocked) +{ + GtkWidget* window; + GtkWidget* web_view; + WebKitWebSettings *settings; + + window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + web_view = webkit_web_view_new(); + + settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(web_view)); + g_object_set(settings, "enable-fullscreen", TRUE, NULL); + webkit_web_view_set_settings(WEBKIT_WEB_VIEW(web_view), settings); + + gtk_container_add(GTK_CONTAINER(window), web_view); + + gtk_widget_show_all(window); + + loop = g_main_loop_new(NULL, TRUE); + + g_signal_connect(web_view, "entering-fullscreen", G_CALLBACK(entering_fullscreen_cb), (gpointer) blocked); + g_signal_connect(web_view, "leaving-fullscreen", G_CALLBACK(leaving_fullscreen_cb), NULL); + + webkit_web_view_load_string(WEBKIT_WEB_VIEW(web_view), "<html><body>" + "<script>" + "var eventName = 'keypress';" + "document.addEventListener(eventName, function () {" + " document.documentElement.webkitRequestFullScreen();" + "}, false);" + "</script></body></html>", NULL, NULL, NULL); + + g_timeout_add(100, (GSourceFunc) emitKeyStroke, WEBKIT_WEB_VIEW(web_view)); + g_main_loop_run(loop); + + gtk_widget_destroy(window); +} + int main(int argc, char** argv) { SoupServer* server; @@ -410,6 +525,9 @@ int main(int argc, char** argv) g_test_add_func("/webkit/webview/grab_focus", test_webkit_web_view_grab_focus); g_test_add_func("/webkit/webview/window-features", test_webkit_web_view_window_features); g_test_add_func("/webkit/webview/webview-in-offscreen-window-does-not-crash", test_webkit_web_view_in_offscreen_window_does_not_crash); + g_test_add_func("/webkit/webview/webview-does-not-steal-focus", test_webkit_web_view_does_not_steal_focus); + g_test_add_data_func("/webkit/webview/fullscreen", GINT_TO_POINTER(FALSE), test_webkit_web_view_fullscreen); + g_test_add_data_func("/webkit/webview/fullscreen-blocked", GINT_TO_POINTER(TRUE), test_webkit_web_view_fullscreen); return g_test_run (); } diff --git a/Source/WebKit/gtk/webkit/webkitglobals.cpp b/Source/WebKit/gtk/webkit/webkitglobals.cpp index 3967c6376..bc5d72604 100644 --- a/Source/WebKit/gtk/webkit/webkitglobals.cpp +++ b/Source/WebKit/gtk/webkit/webkitglobals.cpp @@ -336,12 +336,6 @@ void webkitInit() soup_session_add_feature(session, authDialog); g_object_unref(authDialog); - SoupSessionFeature* sniffer = static_cast<SoupSessionFeature*>(g_object_new(SOUP_TYPE_CONTENT_SNIFFER, NULL)); - soup_session_add_feature(session, sniffer); - g_object_unref(sniffer); - - soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER); - #if USE(CLUTTER) gtk_clutter_init(0, 0); #endif diff --git a/Source/WebKit/gtk/webkit/webkitwebinspector.cpp b/Source/WebKit/gtk/webkit/webkitwebinspector.cpp index c93c2bdb2..692079f68 100644 --- a/Source/WebKit/gtk/webkit/webkitwebinspector.cpp +++ b/Source/WebKit/gtk/webkit/webkitwebinspector.cpp @@ -577,42 +577,3 @@ void webkit_web_inspector_execute_script(WebKitWebInspector* webInspector, long WebKitWebInspectorPrivate* priv = webInspector->priv; priv->page->inspectorController()->evaluateForTestInFrontend(callId, script); } - -#ifdef HAVE_GSETTINGS -static bool isSchemaAvailable(const char* schemaID) -{ - const char* const* availableSchemas = g_settings_list_schemas(); - char* const* iter = const_cast<char* const*>(availableSchemas); - - while (*iter) { - if (g_str_equal(schemaID, *iter)) - return true; - iter++; - } - - return false; -} - -GSettings* inspectorGSettings() -{ - static GSettings* settings = 0; - if (settings) - return settings; - - // Unfortunately GSettings will abort the process execution if the schema is not - // installed, which is the case for when running tests, or even the introspection dump - // at build time, so check if we have the schema before trying to initialize it. - const gchar* schemaID = "org.webkitgtk-"WEBKITGTK_API_VERSION_STRING".inspector"; - if (!isSchemaAvailable(schemaID)) { - - // This warning is very common on the build bots, which hides valid warnings. - // Skip printing it if we are running inside DumpRenderTree. - if (!DumpRenderTreeSupportGtk::dumpRenderTreeModeEnabled()) - g_warning("GSettings schema not found - settings will not be used or saved."); - return 0; - } - - settings = g_settings_new(schemaID); - return settings; -} -#endif diff --git a/Source/WebKit/gtk/webkit/webkitwebinspectorprivate.h b/Source/WebKit/gtk/webkit/webkitwebinspectorprivate.h index 46d57b0b8..64ba09a5d 100644 --- a/Source/WebKit/gtk/webkit/webkitwebinspectorprivate.h +++ b/Source/WebKit/gtk/webkit/webkitwebinspectorprivate.h @@ -25,10 +25,6 @@ extern "C" { -#ifdef HAVE_GSETTINGS -GSettings* inspectorGSettings(); -#endif - void webkit_web_inspector_set_inspector_client(WebKitWebInspector*, WebCore::Page*); void webkit_web_inspector_set_web_view(WebKitWebInspector*, WebKitWebView*); diff --git a/Source/WebKit/gtk/webkit/webkitwebsettings.cpp b/Source/WebKit/gtk/webkit/webkitwebsettings.cpp index d91c3bbf3..bf6ff600d 100644 --- a/Source/WebKit/gtk/webkit/webkitwebsettings.cpp +++ b/Source/WebKit/gtk/webkit/webkitwebsettings.cpp @@ -183,7 +183,7 @@ static String chromeUserAgent() DEFINE_STATIC_LOCAL(const String, uaVersion, (makeString(String::number(WEBKIT_USER_AGENT_MAJOR_VERSION), '.', String::number(WEBKIT_USER_AGENT_MINOR_VERSION), '+'))); DEFINE_STATIC_LOCAL(const String, staticUA, (makeString("Mozilla/5.0 (", webkitPlatform(), webkitOSVersion(), ") AppleWebKit/", uaVersion) + - makeString(" (KHTML, like Gecko) Chromium/15.0.874.120 Chrome/15.0.874.120 Safari/", uaVersion))); + makeString(" (KHTML, like Gecko) Chromium/17.0.963.56 Chrome/17.0.963.56 Safari/", uaVersion))); return staticUA; } diff --git a/Source/WebKit/gtk/webkit/webkitwebview.cpp b/Source/WebKit/gtk/webkit/webkitwebview.cpp index c22461c74..89b9c228f 100644 --- a/Source/WebKit/gtk/webkit/webkitwebview.cpp +++ b/Source/WebKit/gtk/webkit/webkitwebview.cpp @@ -212,6 +212,8 @@ enum { RESOURCE_LOAD_FINISHED, RESOURCE_CONTENT_LENGTH_RECEIVED, RESOURCE_LOAD_FAILED, + ENTERING_FULLSCREEN, + LEAVING_FULLSCREEN, LAST_SIGNAL }; @@ -639,6 +641,9 @@ static gboolean webkit_web_view_expose_event(GtkWidget* widget, GdkEventExpose* copyRectFromCairoSurfaceToContext(WEBKIT_WEB_VIEW(widget)->priv->backingStore->cairoSurface(), cr.get(), IntSize(), IntRect(rects.get()[i])); } + + // Chaining up to the parent forces child widgets to be drawn. + GTK_WIDGET_CLASS(webkit_web_view_parent_class)->expose_event(widget, event); return FALSE; } #else @@ -667,6 +672,8 @@ static gboolean webkit_web_view_draw(GtkWidget* widget, cairo_t* cr) } cairo_rectangle_list_destroy(rectList); + // Chaining up to the parent forces child widgets to be drawn. + GTK_WIDGET_CLASS(webkit_web_view_parent_class)->draw(widget, cr); return FALSE; } #endif // GTK_API_VERSION_2 @@ -1295,6 +1302,16 @@ static gboolean webkit_web_view_real_should_allow_editing_action(WebKitWebView*) return TRUE; } +static gboolean webkit_web_view_real_entering_fullscreen(WebKitWebView* webView) +{ + return FALSE; +} + +static gboolean webkit_web_view_real_leaving_fullscreen(WebKitWebView* webView) +{ + return FALSE; +} + static void webkit_web_view_dispose(GObject* object) { WebKitWebView* webView = WEBKIT_WEB_VIEW(object); @@ -2650,6 +2667,59 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass) G_TYPE_NONE, 1, WEBKIT_TYPE_VIEWPORT_ATTRIBUTES); + /** + * WebKitWebView::entering-fullscreen: + * @web_view: the #WebKitWebView on which the signal is emitted. + * @element: the #WebKitDOMHTMLElement which has requested full screen display. + * + * Emitted when JavaScript code calls + * <function>element.webkitRequestFullScreen</function>. If the + * signal is not handled the WebView will proceed to full screen + * its top level window. This signal can be used by client code to + * request permission to the user prior doing the full screen + * transition and eventually prepare the top-level window + * (e.g. hide some widgets that would otherwise be part of the + * full screen window). + * + * Returns: %TRUE to stop other handlers from being invoked for the event. + * %FALSE to continue emission of the event. + * + * Since: 1.9.0 + */ + webkit_web_view_signals[ENTERING_FULLSCREEN] = + g_signal_new("entering-fullscreen", + G_TYPE_FROM_CLASS(webViewClass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(WebKitWebViewClass, entering_fullscreen), + g_signal_accumulator_true_handled, 0, + webkit_marshal_BOOLEAN__OBJECT, + G_TYPE_BOOLEAN, 1, WEBKIT_TYPE_DOM_HTML_ELEMENT); + + + /** + * WebKitWebView::leaving-fullscreen: + * @web_view: the #WebKitWebView on which the signal is emitted. + * @element: the #WebKitDOMHTMLElement which is currently displayed full screen. + * + * Emitted when the WebView is about to restore its top level + * window out of its full screen state. This signal can be used by + * client code to restore widgets hidden during the + * entering-fullscreen stage for instance. + * + * Returns: %TRUE to stop other handlers from being invoked for the event. + * %FALSE to continue emission of the event. + * + * Since: 1.9.0 + */ + webkit_web_view_signals[LEAVING_FULLSCREEN] = + g_signal_new("leaving-fullscreen", + G_TYPE_FROM_CLASS(webViewClass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(WebKitWebViewClass, leaving_fullscreen), + g_signal_accumulator_true_handled, 0, + webkit_marshal_BOOLEAN__OBJECT, + G_TYPE_BOOLEAN, 1, WEBKIT_TYPE_DOM_HTML_ELEMENT); + /* * WebKitWebView::resource-response-received * @webView: the object which received the signal @@ -2758,6 +2828,8 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass) webViewClass->redo = webkit_web_view_real_redo; webViewClass->move_cursor = webkit_web_view_real_move_cursor; webViewClass->should_allow_editing_action = webkit_web_view_real_should_allow_editing_action; + webViewClass->entering_fullscreen = webkit_web_view_real_entering_fullscreen; + webViewClass->leaving_fullscreen = webkit_web_view_real_leaving_fullscreen; GObjectClass* objectClass = G_OBJECT_CLASS(webViewClass); objectClass->dispose = webkit_web_view_dispose; @@ -3417,11 +3489,6 @@ static void webkit_web_view_init(WebKitWebView* webView) pageClients.dragClient = new WebKit::DragClient(webView); pageClients.inspectorClient = new WebKit::InspectorClient(webView); -#if ENABLE(DEVICE_ORIENTATION) - pageClients.deviceMotionClient = static_cast<WebCore::DeviceMotionClient*>(new DeviceMotionClientGtk); - pageClients.deviceOrientationClient = static_cast<WebCore::DeviceOrientationClient*>(new DeviceOrientationClientGtk); -#endif - #if ENABLE(CLIENT_BASED_GEOLOCATION) if (DumpRenderTreeSupportGtk::dumpRenderTreeModeEnabled()) pageClients.geolocationClient = new GeolocationClientMock; @@ -3431,6 +3498,11 @@ static void webkit_web_view_init(WebKitWebView* webView) priv->corePage = new Page(pageClients); +#if ENABLE(DEVICE_ORIENTATION) + WebCore::provideDeviceMotionTo(priv->corePage, new DeviceMotionClientGtk); + WebCore::provideDeviceOrientationTo(priv->corePage, new DeviceOrientationClientGtk); +#endif + #if ENABLE(CLIENT_BASED_GEOLOCATION) if (DumpRenderTreeSupportGtk::dumpRenderTreeModeEnabled()) static_cast<GeolocationClientMock*>(pageClients.geolocationClient)->setController(priv->corePage->geolocationController()); diff --git a/Source/WebKit/gtk/webkit/webkitwebview.h b/Source/WebKit/gtk/webkit/webkitwebview.h index 678e32966..2a15b53c6 100644 --- a/Source/WebKit/gtk/webkit/webkitwebview.h +++ b/Source/WebKit/gtk/webkit/webkitwebview.h @@ -176,11 +176,11 @@ struct _WebKitWebViewClass { void (* undo) (WebKitWebView *web_view); void (* redo) (WebKitWebView *web_view); gboolean (* should_allow_editing_action) (WebKitWebView *web_view); + gboolean (* entering_fullscreen) (WebKitWebView *web_view); + gboolean (* leaving_fullscreen) (WebKitWebView *web_view); /* Padding for future expansion */ void (*_webkit_reserved0) (void); - void (*_webkit_reserved1) (void); - void (*_webkit_reserved2) (void); }; WEBKIT_API GType diff --git a/Source/WebKit/mac/ChangeLog b/Source/WebKit/mac/ChangeLog index bf1173720..898482ec1 100644 --- a/Source/WebKit/mac/ChangeLog +++ b/Source/WebKit/mac/ChangeLog @@ -1,3 +1,458 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/WebEditorClient.h: + * WebCoreSupport/WebEditorClient.mm: + (WebEditorClient::requestCheckingOfString): + +2012-02-23 Andy Estes <aestes@apple.com> + + Rename [setS|s]uppressIncrementalRendering to [setS|s]uppressesIncrementalRendering and make it WebPreferences API. + https://bugs.webkit.org/show_bug.cgi?id=79433 + + Reviewed by Dan Bernstein. + + * WebCoreSupport/WebInspectorClient.mm: + (-[WebInspectorWindowController init]): + * WebView/WebPreferenceKeysPrivate.h: + * WebView/WebPreferences.h: + * WebView/WebPreferences.mm: + (+[WebPreferences initialize]): + (-[WebPreferences setSuppressesIncrementalRendering:]): + (-[WebPreferences suppressesIncrementalRendering]): + (-[WebPreferences setSuppressIncrementalRendering:]): + (-[WebPreferences suppressIncrementalRendering]): + * WebView/WebView.mm: + (-[WebView _preferencesChanged:]): + +2012-02-22 Hajime Morrita <morrita@chromium.org> + + NOTIFICATIONS should be implemented as PageSupplement + https://bugs.webkit.org/show_bug.cgi?id=79052 + + Reviewed by Adam Barth. + + * WebView/WebView.mm: + (-[WebView _commonInitializationWithFrameName:groupName:]): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/WebEditorClient.h: + (WebEditorClient): + * WebCoreSupport/WebEditorClient.mm: + (WebEditorClient::shouldApplyStyle): + * WebView/WebFrame.mm: + (-[WebFrame _setTypingStyle:withUndoAction:]): + * WebView/WebHTMLView.mm: + (-[WebHTMLView _applyStyleToSelection:withUndoAction:]): + (-[WebHTMLView _changeCSSColorUsingSelector:inRange:]): + * WebView/WebView.mm: + (-[WebView applyStyle:]): + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/WebEditorClient.h: + (WebEditorClient): + * WebCoreSupport/WebEditorClient.mm: + (WebEditorClient::shouldApplyStyle): + * WebView/WebFrame.mm: + (-[WebFrame _setTypingStyle:withUndoAction:]): + * WebView/WebHTMLView.mm: + (-[WebHTMLView _applyStyleToSelection:withUndoAction:]): + (-[WebHTMLView _changeCSSColorUsingSelector:inRange:]): + * WebView/WebView.mm: + (-[WebView applyStyle:]): + +2012-02-22 Jon Lee <jonlee@apple.com> + + Part of r108409 was incorrect, and incorporated an older version of a sub-patch. + This is the actual sub-patch that should have been submitted. + + * WebCoreSupport/WebNotificationClient.h: + * WebCoreSupport/WebNotificationClient.mm: + (WebNotificationClient::show): + (WebNotificationClient::cancel): + (WebNotificationClient::clearNotifications): + (WebNotificationClient::notificationObjectDestroyed): + (WebNotificationClient::notificationControllerDestroyed): + +2012-02-21 Jon Lee <jonlee@apple.com> + + Build fix. Push ENABLE_NOTIFICATIONS into .mm file. + + * WebCoreSupport/WebNotificationClient.h: + * WebView/WebNotification.h: + * WebView/WebNotification.mm: + (-[WebNotification title]): + (-[WebNotification body]): + (-[WebNotification origin]): + (-[WebNotification notificationID]): + (-[WebNotification dispatchShowEvent]): + (-[WebNotification dispatchCloseEvent]): + (-[WebNotification dispatchClickEvent]): + (-[WebNotification dispatchErrorEvent]): + +2012-02-21 John Sullivan <sullivan@apple.com> + + Build fix. + + * WebView/WebUIDelegatePrivate.h: + Added @class declarations for DOMNode and DOMElement. + +2012-02-21 Jon Lee <jonlee@apple.com> + + Build fix for r108409. + + * WebCoreSupport/WebNotificationClient.h: + (WebCore): + * WebCoreSupport/WebNotificationClient.mm: + * WebView/WebNotification.h: + (WebSecurityOrigin): + * WebView/WebNotification.mm: + (core): + (-[WebNotification initWithCoreNotification:notificationID:]): + +2012-02-21 Jon Lee <jonlee@apple.com> + + Bring notifications support to WK1 mac: permission requests + https://bugs.webkit.org/show_bug.cgi?id=78783 + <rdar://problem/10610578> + + Reviewed by Anders Carlsson. + + * WebCoreSupport/WebNotificationClient.h: + * WebCoreSupport/WebNotificationClient.mm: Create policy listener, which conforms to the + WebAllowDenyPolicyListener protocol, similar to geolocation. + (WebNotificationClient::requestPermission): + (WebNotificationClient::checkPermission): + (-[WebNotificationPolicyListener initWithCallback:]): + (-[WebNotificationPolicyListener allow]): Call the callback. + (-[WebNotificationPolicyListener deny]): Call the callback. + * WebView/WebUIDelegatePrivate.h: Define new UI delegate method to ask the user to decide a + policy for navigations. + + ==== + Bring notifications support to WK1 mac: showing, canceling, removing notifications + + Create a WebKit wrapper object for WebCore::Notification, which also keeps track of an assigned + ID. + * WebView/WebNotification.h: Added. + (WebSecurityOrigin): + * WebView/WebNotification.mm: Added. + (core): + (-[WebNotification initWithCoreNotification:notificationID:]): + (-[WebNotification init]): + (-[WebNotification dealloc]): + (-[WebNotification title]): + (-[WebNotification body]): + (-[WebNotification origin]): + (-[WebNotification notificationID]): + (-[WebNotification dispatchShowEvent]): + (-[WebNotification dispatchCloseEvent]): + (-[WebNotification dispatchClickEvent]): + (-[WebNotification dispatchErrorEvent]): + * WebView/WebNotificationInternal.h: Added. + (WebCore): Internal category to allow creating instances with WebCore objects. + + Extend WebView to include a WebNotificationProvider, which clients implement. + * WebView/WebViewData.h: Add a private member for the provider. + * WebView/WebViewPrivate.h: + * Define an enum WebNotificationPermission that mirrors WebCore::NotificationPresenter::Permission + that client which implement the provider can use to return policy decisions. + * Define WebNotificationProvider. + * Category WebViewNotification extends WebView with methods that set and manager the + notification provider, and handle events from the platform notifications. + * WebView/WebView.mm: + (-[WebView _setNotificationProvider:]): Sets the provider when initializing the WebView. + (-[WebView _notificationControllerDestroyed]): + (-[WebView _notificationProvider]): + (-[WebView _notificationDidShow:]): + (-[WebView _notificationDidClick:]): + (-[WebView _notificationsDidClose:]): + + * WebCoreSupport/WebNotificationClient.h: Add variables that map between WebCore::Notification + instances, their assigned IDs, their contexts, and corresponding WebKit wrapper objects. + * WebCoreSupport/WebNotificationClient.mm: + (generateNotificationID): Created unique IDs for each shown notification. + (WebNotificationClient::show): Create wrapper object for notification, assign ID, cache the + mappings between the objects, and forward it to the provider. + (WebNotificationClient::cancel): + (WebNotificationClient::clearNotifications): Clear all notifications associated with the + provided context. + (WebNotificationClient::notificationObjectDestroyed): Remove the notification from the maps. + (WebNotificationClient::notificationControllerDestroyed): If the controller is destroyed, tell + the provider to clear of the notifications related to this web view. + + ==== + (Prep work for) Bring notifications support to WK1 mac + + Rename WebGeolocationPolicyListener. The interface is generic enough to be reused for + notification requests. To avoid having to create a new listener type, instead rename it + to WebAllowDenyPolicyListener. + * WebView/WebUIDelegatePrivate.h: Rename the protocol. + * WebCoreSupport/WebGeolocationClient.mm: Refactor geolocation request listener to use + new name. + + Add preference to keep track of whether notifications are enabled in general. + * WebView/WebPreferenceKeysPrivate.h: Add WebNotificationsEnabledKey for storing the + preference. + * WebView/WebPreferences.mm: + (+[WebPreferences initialize]): By default have them enabled. + (-[WebPreferences setNotificationsEnabled:]): + (-[WebPreferences notificationsEnabled]): + * WebView/WebPreferencesPrivate.h: + + Add a stringValue method that exposes WebCore::SecurityOrigin::toString() for storing the + notification policy for a given origin. + * WebCoreSupport/WebSecurityOrigin.mm: + (-[WebSecurityOrigin stringValue]): + * WebCoreSupport/WebSecurityOriginPrivate.h: + +2012-02-21 Sam Weinig <sam@webkit.org> + + Attempt to fix the Snow Leopard build. + + * Configurations/Base.xcconfig: + +2012-02-21 Sam Weinig <sam@webkit.org> + + Use libc++ when building with Clang on Mac + https://bugs.webkit.org/show_bug.cgi?id=78981 + + Reviewed by Dan Bernstein. + + * Configurations/Base.xcconfig: + +2012-02-17 Mihnea Ovidenie <mihnea@adobe.com> + + CSS regions enabled by default + https://bugs.webkit.org/show_bug.cgi?id=78525 + + Reviewed by David Hyatt. + + Add a runtime preference to enable/disable regions functionality at runtime(WebKitCSSRegionsEnabled). + CSSRegions are still enabled by default. + In DRT, use layoutTestController.overridePreference("WebKitCSSRegionsEnabled", "0") to disable the css regions functionality. + + * WebView/WebPreferenceKeysPrivate.h: + * WebView/WebPreferences.mm: + (+[WebPreferences initialize]): + (-[WebPreferences cssRegionsEnabled]): + (-[WebPreferences setCSSRegionsEnabled:]): + * WebView/WebPreferencesPrivate.h: + * WebView/WebView.mm: + (-[WebView _preferencesChanged:]): + +2012-02-17 Enrica Casucci <enrica@apple.com> + + Refactor DragData class to use PlatformStrategies in the Mac implementation. + https://bugs.webkit.org/show_bug.cgi?id=78768 + + Reviewed by Darin Adler. + + * WebCoreSupport/WebPlatformStrategies.h: Added color() method. + * WebCoreSupport/WebPlatformStrategies.mm: + (WebPlatformStrategies::color): + +2012-02-16 Brady Eidson <beidson@apple.com> + + <rdar://problem/10616280> and https://bugs.webkit.org/show_bug.cgi?id=78767 + REGRESSION (r90471) - iAd Producer 2.0.1 produces blank pages + + Reviewed by Sam Weinig. + + * WebView/WebView.mm: + (-[WebView _needsIsLoadingInAPISenseQuirk]): + (-[WebView _preferencesChanged:]): + +2012-02-15 Enrica Casucci <enrica@apple.com> + + Refactor ClipboardMac class to use PlatformStrategies. + https://bugs.webkit.org/show_bug.cgi?id=78554 + + Reviewed by Anders Carlsson. + + * WebCoreSupport/WebDragClient.h: Changed methods signature to use name based pasteboard. + * WebCoreSupport/WebDragClient.mm: Ditto. + (WebDragClient::willPerformDragSourceAction): + (WebDragClient::startDrag): + (WebDragClient::declareAndWriteDragImage): + * WebCoreSupport/WebPlatformStrategies.h: Added new methods. + * WebCoreSupport/WebPlatformStrategies.mm: + (WebPlatformStrategies::changeCount): + (WebPlatformStrategies::uniqueName): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebCoreSupport/WebChromeClient.h: + +2012-02-14 Matt Lilek <mrl@apple.com> + + Don't ENABLE_DASHBOARD_SUPPORT unconditionally on all Mac platforms + https://bugs.webkit.org/show_bug.cgi?id=78629 + + Reviewed by David Kilzer. + + * Configurations/FeatureDefines.xcconfig: + +2012-02-14 Alexey Proskuryakov <ap@apple.com> + + [Mac][Win][WK2] Switch to RFC 6455 protocol for WebSockets + https://bugs.webkit.org/show_bug.cgi?id=78541 + <rdar://problem/10036695> + + Reviewed by Kent Tamura. + + * WebView/WebPreferences.mm: (+[WebPreferences initialize]): Changed default value of the + preference. + +2012-02-11 Nikolas Zimmermann <nzimmermann@rim.com> + + Convert svg/animations to use SMIL methods for driving the timeline + https://bugs.webkit.org/show_bug.cgi?id=78422 + + Reviewed by Dirk Schulze. + + Remove SVG animation sampling functionality provided for DRT, which no longer uses it. + Instead we switched the svg/animations tests to use SVGSVGElement.setCurrentTime. + + * WebKit.order: + * WebView/WebFrame.mm: + * WebView/WebFramePrivate.h: + +2012-02-13 Enrica Casucci <enrica@apple.com> + + Refactor Mac platform implementation of the Pasteboard class to use Platform Strategies. + https://bugs.webkit.org/show_bug.cgi?id=78282 + + This patch removes any accesss to the NSPasteboard object from the Pasteboard class which + now makes use of a new pasteboardStrategy object that is implemented both in WebKit and + WebKit2. The actual access to NSPasteboard is now performed inside the PlatformPasteboard + class. Currently both WebKit and WebKit2 use the same implementation of the PasteboardStrategy + interface but this one more step in the direction of removing access to NSPasteboard from + the WebProcess. + As part of the refactoring the I've reduced to a minimum the use of OBJ-C classes. + + Reviewed by Anders Carlsson. + + * WebCoreSupport/WebPlatformStrategies.h: Added PasteboardStrategy. + * WebCoreSupport/WebPlatformStrategies.mm: Added implementation of PasteboardStrategy interface. + (WebPlatformStrategies::createPasteboardStrategy): + (WebPlatformStrategies::getTypes): + (WebPlatformStrategies::bufferForType): + (WebPlatformStrategies::getPathnamesForType): + (WebPlatformStrategies::stringForType): + (WebPlatformStrategies::copy): + (WebPlatformStrategies::setTypes): + (WebPlatformStrategies::setBufferForType): + (WebPlatformStrategies::setPathnamesForType): + (WebPlatformStrategies::setStringForType): + +2012-02-12 Hajime Morrita <morrita@chromium.org> + + Page should have less intrusive way to associate API implementation objects. + https://bugs.webkit.org/show_bug.cgi?id=78085 + + Reviewed by Adam Barth. + + * WebView/WebView.mm: + (-[WebView _commonInitializationWithFrameName:groupName:]): + +2012-02-11 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r107435. + http://trac.webkit.org/changeset/107435 + https://bugs.webkit.org/show_bug.cgi?id=78410 + + It broke the Qt build (Requested by Ossy on #webkit). + + * WebCoreSupport/WebPlatformStrategies.h: + (WebPlatformStrategies): + * WebCoreSupport/WebPlatformStrategies.mm: + (WebPlatformStrategies::addVisitedLink): + +2012-02-10 Adam Klein <adamk@chromium.org> + + Enable MUTATION_OBSERVERS by default on all platforms + https://bugs.webkit.org/show_bug.cgi?id=78196 + + Reviewed by Ojan Vafai. + + * Configurations/FeatureDefines.xcconfig: + +2012-02-10 Enrica Casucci <enrica@apple.com> + + Refactor Mac platform implementation of the Pasteboard class to use Platform Strategies. + https://bugs.webkit.org/show_bug.cgi?id=78282 + + This patch removes any accesss to the NSPasteboard object from the Pasteboard class which + now makes use of a new pasteboardStrategy object that is implemented both in WebKit and + WebKit2. The actual access to NSPasteboard is now performed inside the PlatformPasteboard + class. Currently both WebKit and WebKit2 use the same implementation of the PasteboardStrategy + interface but this one more step in the direction of removing access to NSPasteboard from + the WebProcess. + As part of the refactoring the I've reduced to a minimum the use of OBJ-C classes. + + Reviewed by Anders Carlsson. + + * WebCoreSupport/WebPlatformStrategies.h: Added PasteboardStrategy. + * WebCoreSupport/WebPlatformStrategies.mm: Added implementation of PasteboardStrategy interface. + (WebPlatformStrategies::createPasteboardStrategy): + (WebPlatformStrategies::getTypes): + (WebPlatformStrategies::bufferForType): + (WebPlatformStrategies::getPathnamesForType): + (WebPlatformStrategies::stringForType): + (WebPlatformStrategies::copy): + (WebPlatformStrategies::setTypes): + (WebPlatformStrategies::setBufferForType): + (WebPlatformStrategies::setPathnamesForType): + (WebPlatformStrategies::setStringForType): + +2012-02-10 Benjamin Poulain <bpoulain@apple.com> + + [Mac] DYLIB_INSTALL_NAME_BASE should not be prefixed by the SDKROOT + https://bugs.webkit.org/show_bug.cgi?id=78320 + + Reviewed by Joseph Pecoraro. + + <rdar://problem/10839750> + + * Configurations/WebKit.xcconfig: + +2012-02-09 Alexey Proskuryakov <ap@apple.com> + + REGRESSION (r104885): Articles not displayed in Vienna RSS reader + https://bugs.webkit.org/show_bug.cgi?id=78280 + <rdar://problem/10762545> + + Reviewed by Oliver Hunt. + + * Misc/WebNSURLExtras.h: + * Misc/WebNSURLExtras.mm: (-[NSURL _webkit_URLFromURLOrPath]): + Added a method to create a URL from a path, similarly to what KURL used to do. + + * WebView/WebFrame.mm: (-[WebFrame loadData:MIMEType:textEncodingName:baseURL:]): + Use it in an API where a known regression occurred. + 2012-02-07 Antti Koivisto <antti@apple.com> REGRESSION (r106681): Null check missing in [WebFrame(WebInternal) _typingStyle] diff --git a/Source/WebKit/mac/Configurations/Base.xcconfig b/Source/WebKit/mac/Configurations/Base.xcconfig index 648332252..b62984744 100644 --- a/Source/WebKit/mac/Configurations/Base.xcconfig +++ b/Source/WebKit/mac/Configurations/Base.xcconfig @@ -65,6 +65,11 @@ WARNING_CFLAGS_iphoneos = $(WARNING_CFLAGS_BASE); WARNING_CFLAGS_iphonesimulator = $(WARNING_CFLAGS_BASE); WARNING_CFLAGS_macosx = $(WARNING_CFLAGS_BASE); +CLANG_CXX_LIBRARY = $(CLANG_CXX_LIBRARY_$(TARGET_MAC_OS_X_VERSION_MAJOR)); +CLANG_CXX_LIBRARY_1060 = libstdc++; +CLANG_CXX_LIBRARY_1070 = libc++; +CLANG_CXX_LIBRARY_1080 = libc++; +CLANG_CXX_LIBRARY_1090 = libc++; REAL_PLATFORM_NAME = $(REAL_PLATFORM_NAME_$(PLATFORM_NAME)); REAL_PLATFORM_NAME_ = $(REAL_PLATFORM_NAME_macosx); diff --git a/Source/WebKit/mac/Configurations/FeatureDefines.xcconfig b/Source/WebKit/mac/Configurations/FeatureDefines.xcconfig index f5bc9cf39..3e2090355 100644 --- a/Source/WebKit/mac/Configurations/FeatureDefines.xcconfig +++ b/Source/WebKit/mac/Configurations/FeatureDefines.xcconfig @@ -37,7 +37,8 @@ ENABLE_BLOB_macosx = ENABLE_BLOB; ENABLE_CLIENT_BASED_GEOLOCATION = $(ENABLE_CLIENT_BASED_GEOLOCATION_$(REAL_PLATFORM_NAME)); ENABLE_CLIENT_BASED_GEOLOCATION_macosx = ENABLE_CLIENT_BASED_GEOLOCATION; -ENABLE_DASHBOARD_SUPPORT = ENABLE_DASHBOARD_SUPPORT; +ENABLE_DASHBOARD_SUPPORT = $(ENABLE_DASHBOARD_SUPPORT_$(REAL_PLATFORM_NAME)); +ENABLE_DASHBOARD_SUPPORT_macosx = ENABLE_DASHBOARD_SUPPORT; ENABLE_DATALIST = $(ENABLE_DATALIST_$(REAL_PLATFORM_NAME)); ENABLE_DATALIST_macosx = ENABLE_DATALIST; @@ -95,7 +96,7 @@ ENABLE_MEDIA_SOURCE = ; ENABLE_MEDIA_STATISTICS = ; ENABLE_METER_TAG = ENABLE_METER_TAG; ENABLE_MHTML = ; -ENABLE_MUTATION_OBSERVERS = ; +ENABLE_MUTATION_OBSERVERS = ENABLE_MUTATION_OBSERVERS; ENABLE_NOTIFICATIONS = $(ENABLE_NOTIFICATIONS_$(REAL_PLATFORM_NAME)); ENABLE_NOTIFICATIONS_macosx = $(ENABLE_NOTIFICATIONS_macosx_$(TARGET_MAC_OS_X_VERSION_MAJOR)); diff --git a/Source/WebKit/mac/Configurations/Version.xcconfig b/Source/WebKit/mac/Configurations/Version.xcconfig index 20bc364c1..5344a720d 100644 --- a/Source/WebKit/mac/Configurations/Version.xcconfig +++ b/Source/WebKit/mac/Configurations/Version.xcconfig @@ -22,7 +22,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. MAJOR_VERSION = 535; -MINOR_VERSION = 20; +MINOR_VERSION = 23; TINY_VERSION = 0; FULL_VERSION = $(MAJOR_VERSION).$(MINOR_VERSION); diff --git a/Source/WebKit/mac/Configurations/WebKit.xcconfig b/Source/WebKit/mac/Configurations/WebKit.xcconfig index 7e0ac2979..0a0cf9f41 100644 --- a/Source/WebKit/mac/Configurations/WebKit.xcconfig +++ b/Source/WebKit/mac/Configurations/WebKit.xcconfig @@ -83,8 +83,8 @@ WEBKIT_FRAMEWORKS_DIR_macosx_USE_STAGING_INSTALL_PATH_NO = $(NORMAL_WEBKIT_FRAME WEBKIT_FRAMEWORKS_DIR_macosx_USE_STAGING_INSTALL_PATH_YES = $(SYSTEM_LIBRARY_DIR)/StagedFrameworks/Safari; NORMAL_PRODUCTION_FRAMEWORKS_DIR = $(NORMAL_PRODUCTION_FRAMEWORKS_DIR_$(REAL_PLATFORM_NAME)); -NORMAL_PRODUCTION_FRAMEWORKS_DIR_iphoneos = $(SDKROOT)$(SYSTEM_LIBRARY_DIR)/PrivateFrameworks; -NORMAL_PRODUCTION_FRAMEWORKS_DIR_iphonesimulator = $(PRODUCTION_FRAMEWORKS_DIR_iphoneos); +NORMAL_PRODUCTION_FRAMEWORKS_DIR_iphoneos = $(SYSTEM_LIBRARY_DIR)/PrivateFrameworks; +NORMAL_PRODUCTION_FRAMEWORKS_DIR_iphonesimulator = $(NORMAL_PRODUCTION_FRAMEWORKS_DIR_iphoneos); NORMAL_PRODUCTION_FRAMEWORKS_DIR_macosx = $(NEXT_ROOT)$(SYSTEM_LIBRARY_DIR)/Frameworks; PRODUCTION_FRAMEWORKS_DIR = $(PRODUCTION_FRAMEWORKS_DIR_$(REAL_PLATFORM_NAME)); diff --git a/Source/WebKit/mac/Misc/WebNSURLExtras.h b/Source/WebKit/mac/Misc/WebNSURLExtras.h index c7b266e93..6b170a7bb 100644 --- a/Source/WebKit/mac/Misc/WebNSURLExtras.h +++ b/Source/WebKit/mac/Misc/WebNSURLExtras.h @@ -69,6 +69,8 @@ - (NSString *)_webkit_suggestedFilenameWithMIMEType:(NSString *)MIMEType; +- (NSURL *)_webkit_URLFromURLOrPath; + @end @interface NSString (WebNSURLExtras) diff --git a/Source/WebKit/mac/Misc/WebNSURLExtras.mm b/Source/WebKit/mac/Misc/WebNSURLExtras.mm index b408bd4a3..c2351dd3d 100644 --- a/Source/WebKit/mac/Misc/WebNSURLExtras.mm +++ b/Source/WebKit/mac/Misc/WebNSURLExtras.mm @@ -883,6 +883,14 @@ static CFStringRef createStringWithEscapedUnsafeCharacters(CFStringRef string) return suggestedFilenameWithMIMEType(self, MIMEType); } +- (NSURL *)_webkit_URLFromURLOrPath +{ + if ([self scheme]) + return self; + + return [NSURL fileURLWithPath:[self absoluteString]]; +} + @end @implementation NSString (WebNSURLExtras) diff --git a/Source/WebKit/mac/WebCoreSupport/WebChromeClient.h b/Source/WebKit/mac/WebCoreSupport/WebChromeClient.h index 48ff09bba..66fa060b5 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebChromeClient.h +++ b/Source/WebKit/mac/WebCoreSupport/WebChromeClient.h @@ -189,6 +189,7 @@ public: #endif virtual void numWheelEventHandlersChanged(unsigned) OVERRIDE { } + virtual void numTouchEventHandlersChanged(unsigned) OVERRIDE { } virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const OVERRIDE { return false; } private: WebView *m_webView; diff --git a/Source/WebKit/mac/WebCoreSupport/WebDragClient.h b/Source/WebKit/mac/WebCoreSupport/WebDragClient.h index e472fb7ce..9d96b82c5 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebDragClient.h +++ b/Source/WebKit/mac/WebCoreSupport/WebDragClient.h @@ -36,7 +36,7 @@ public: virtual void dragControllerDestroyed() OVERRIDE; virtual WebCore::DragSourceAction dragSourceActionMaskForPoint(const WebCore::IntPoint& windowPoint) OVERRIDE; virtual void startDrag(WebCore::DragImageRef, const WebCore::IntPoint& dragPos, const WebCore::IntPoint& eventPos, WebCore::Clipboard*, WebCore::Frame*, bool linkDrag) OVERRIDE; - virtual void declareAndWriteDragImage(NSPasteboard*, DOMElement*, NSURL*, NSString*, WebCore::Frame*) OVERRIDE; + virtual void declareAndWriteDragImage(const String& pasteboardName, DOMElement*, NSURL*, NSString*, WebCore::Frame*) OVERRIDE; private: WebView* m_webView; }; diff --git a/Source/WebKit/mac/WebCoreSupport/WebDragClient.mm b/Source/WebKit/mac/WebCoreSupport/WebDragClient.mm index 9ba4b05dc..aff7ec2cf 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebDragClient.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebDragClient.mm @@ -83,7 +83,7 @@ WebCore::DragSourceAction WebDragClient::dragSourceActionMaskForPoint(const IntP void WebDragClient::willPerformDragSourceAction(WebCore::DragSourceAction action, const WebCore::IntPoint& mouseDownPoint, WebCore::Clipboard* clipboard) { ASSERT(clipboard); - [[m_webView _UIDelegateForwarder] webView:m_webView willPerformDragSourceAction:(WebDragSourceAction)action fromPoint:mouseDownPoint withPasteboard:static_cast<WebCore::ClipboardMac*>(clipboard)->pasteboard()]; + [[m_webView _UIDelegateForwarder] webView:m_webView willPerformDragSourceAction:(WebDragSourceAction)action fromPoint:mouseDownPoint withPasteboard:[NSPasteboard pasteboardWithName:static_cast<WebCore::ClipboardMac*>(clipboard)->pasteboardName()]]; } void WebDragClient::startDrag(DragImageRef dragImage, const IntPoint& at, const IntPoint& eventPos, Clipboard* clipboard, Frame* frame, bool linkDrag) @@ -100,7 +100,7 @@ void WebDragClient::startDrag(DragImageRef dragImage, const IntPoint& at, const RetainPtr<WebHTMLView> topViewProtector = topHTMLView; [topHTMLView _stopAutoscrollTimer]; - NSPasteboard *pasteboard = static_cast<ClipboardMac*>(clipboard)->pasteboard(); + NSPasteboard *pasteboard = [NSPasteboard pasteboardWithName:static_cast<ClipboardMac*>(clipboard)->pasteboardName()]; NSImage *dragNSImage = dragImage.get(); WebHTMLView *sourceHTMLView = htmlView.get(); @@ -120,14 +120,14 @@ void WebDragClient::startDrag(DragImageRef dragImage, const IntPoint& at, const [topHTMLView dragImage:dragNSImage at:at offset:NSZeroSize event:event pasteboard:pasteboard source:sourceHTMLView slideBack:YES]; } -void WebDragClient::declareAndWriteDragImage(NSPasteboard* pasteboard, DOMElement* element, NSURL* URL, NSString* title, WebCore::Frame* frame) +void WebDragClient::declareAndWriteDragImage(const String& pasteboardName, DOMElement* element, NSURL* URL, NSString* title, WebCore::Frame* frame) { - ASSERT(pasteboard); + ASSERT(pasteboardName); ASSERT(element); WebHTMLView *source = getTopHTMLView(frame); WebArchive *archive = [element webArchive]; - [pasteboard _web_declareAndWriteDragImageForElement:element URL:URL title:title archive:archive source:source]; + [[NSPasteboard pasteboardWithName:pasteboardName] _web_declareAndWriteDragImageForElement:element URL:URL title:title archive:archive source:source]; } void WebDragClient::dragControllerDestroyed() diff --git a/Source/WebKit/mac/WebCoreSupport/WebEditorClient.h b/Source/WebKit/mac/WebCoreSupport/WebEditorClient.h index c70d6089d..c75fee09f 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebEditorClient.h +++ b/Source/WebKit/mac/WebCoreSupport/WebEditorClient.h @@ -61,7 +61,7 @@ public: virtual bool shouldInsertText(const WTF::String&, WebCore::Range*, WebCore::EditorInsertAction) OVERRIDE; virtual bool shouldChangeSelectedRange(WebCore::Range* fromRange, WebCore::Range* toRange, WebCore::EAffinity, bool stillSelecting) OVERRIDE; - virtual bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*) OVERRIDE; + virtual bool shouldApplyStyle(WebCore::StylePropertySet*, WebCore::Range*) OVERRIDE; virtual bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range* rangeToBeReplaced) OVERRIDE; @@ -135,7 +135,7 @@ public: virtual void getGuessesForWord(const WTF::String& word, const WTF::String& context, WTF::Vector<WTF::String>& guesses) OVERRIDE; virtual void willSetInputMethodState() OVERRIDE; virtual void setInputMethodState(bool enabled) OVERRIDE; - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&) OVERRIDE; + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&) OVERRIDE; #if !defined(BUILDING_ON_LEOPARD) && !defined(BUILDING_ON_SNOW_LEOPARD) virtual void showCorrectionPanel(WebCore::CorrectionPanelInfo::PanelType, const WebCore::FloatRect& boundingBoxOfReplacedString, const String& replacedString, const String& replacementString, const Vector<String>& alternativeReplacementStrings) OVERRIDE; virtual void dismissCorrectionPanel(WebCore::ReasonForDismissingCorrectionPanel) OVERRIDE; diff --git a/Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm b/Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm index fabdf6c6f..478553034 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm @@ -241,10 +241,10 @@ bool WebEditorClient::isSelectTrailingWhitespaceEnabled() return [m_webView isSelectTrailingWhitespaceEnabled]; } -bool WebEditorClient::shouldApplyStyle(CSSStyleDeclaration* style, Range* range) +bool WebEditorClient::shouldApplyStyle(StylePropertySet* style, Range* range) { return [[m_webView _editingDelegateForwarder] webView:m_webView - shouldApplyStyle:kit(style) toElementsInDOMRange:kit(range)]; + shouldApplyStyle:kit(style->ensureCSSStyleDeclaration()) toElementsInDOMRange:kit(range)]; } bool WebEditorClient::shouldMoveRangeAfterDelete(Range* range, Range* rangeToBeReplaced) @@ -972,15 +972,15 @@ void WebEditorClient::setInputMethodState(bool) @end #endif -void WebEditorClient::requestCheckingOfString(WebCore::SpellChecker* sender, int sequence, WebCore::TextCheckingTypeMask checkingTypes, const String& text) +void WebEditorClient::requestCheckingOfString(WebCore::SpellChecker* sender, const WebCore::TextCheckingRequest& request) { #ifndef BUILDING_ON_LEOPARD - NSRange range = NSMakeRange(0, text.length()); + NSRange range = NSMakeRange(0, request.text().length()); NSRunLoop* currentLoop = [NSRunLoop currentRunLoop]; - [[NSSpellChecker sharedSpellChecker] requestCheckingOfString:text range:range types:NSTextCheckingAllSystemTypes options:0 inSpellDocumentWithTag:0 + [[NSSpellChecker sharedSpellChecker] requestCheckingOfString:request.text() range:range types:NSTextCheckingAllSystemTypes options:0 inSpellDocumentWithTag:0 completionHandler:^(NSInteger, NSArray* results, NSOrthography*, NSInteger) { [currentLoop performSelector:@selector(perform) - target:[[[WebEditorSpellCheckResponder alloc] initWithSender:sender sequence:sequence types:checkingTypes results:results] autorelease] + target:[[[WebEditorSpellCheckResponder alloc] initWithSender:sender sequence:request.sequence() types:request.mask() results:results] autorelease] argument:nil order:0 modes:[NSArray arrayWithObject:NSDefaultRunLoopMode]]; }]; #endif diff --git a/Source/WebKit/mac/WebCoreSupport/WebGeolocationClient.mm b/Source/WebKit/mac/WebCoreSupport/WebGeolocationClient.mm index b52b7bc64..541f40ccd 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebGeolocationClient.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebGeolocationClient.mm @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 Apple Inc. All rights reserved. + * Copyright (C) 2009, 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -37,7 +37,7 @@ using namespace WebCore; -@interface WebGeolocationPolicyListener : NSObject <WebGeolocationPolicyListener> +@interface WebGeolocationPolicyListener : NSObject <WebAllowDenyPolicyListener> { RefPtr<Geolocation> _geolocation; } diff --git a/Source/WebKit/mac/WebCoreSupport/WebInspectorClient.mm b/Source/WebKit/mac/WebCoreSupport/WebInspectorClient.mm index 14ebd1d65..2ae865951 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebInspectorClient.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebInspectorClient.mm @@ -240,7 +240,7 @@ void WebInspectorFrontendClient::updateWindowTitle() const [preferences setMinimumFontSize:0]; [preferences setMinimumLogicalFontSize:9]; [preferences setPlugInsEnabled:NO]; - [preferences setSuppressIncrementalRendering:YES]; + [preferences setSuppressesIncrementalRendering:YES]; [preferences setTabsToLinks:NO]; [preferences setUserStyleSheetEnabled:NO]; diff --git a/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.h b/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.h index 82903ca59..a40ce81e5 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.h +++ b/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Apple Inc. All rights reserved. + * Copyright (C) 2011, 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -25,11 +25,20 @@ #import <WebCore/NotificationPresenter.h> +#if ENABLE(NOTIFICATIONS) +#import <WebCore/Notification.h> +#import <wtf/HashMap.h> +#import <wtf/RefPtr.h> +#import <wtf/RetainPtr.h> +#endif + namespace WebCore { +class Notification; class ScriptExecutionContext; class VoidCallback; } +@class WebNotification; @class WebView; class WebNotificationClient : public WebCore::NotificationPresenter { @@ -40,11 +49,18 @@ public: private: virtual bool show(WebCore::Notification*) OVERRIDE; virtual void cancel(WebCore::Notification*) OVERRIDE; + virtual void clearNotifications(WebCore::ScriptExecutionContext*) OVERRIDE; virtual void notificationObjectDestroyed(WebCore::Notification*) OVERRIDE; virtual void notificationControllerDestroyed() OVERRIDE; virtual void requestPermission(WebCore::ScriptExecutionContext*, PassRefPtr<WebCore::VoidCallback>) OVERRIDE; - virtual void cancelRequestsForPermission(WebCore::ScriptExecutionContext*) OVERRIDE; + virtual void cancelRequestsForPermission(WebCore::ScriptExecutionContext*) OVERRIDE { } virtual WebCore::NotificationPresenter::Permission checkPermission(WebCore::ScriptExecutionContext*) OVERRIDE; WebView *m_webView; +#if ENABLE(NOTIFICATIONS) + HashMap<RefPtr<WebCore::Notification>, RetainPtr<WebNotification> > m_notificationMap; + + typedef HashMap<RefPtr<WebCore::ScriptExecutionContext>, Vector<RetainPtr<WebNotification> > > NotificationContextMap; + NotificationContextMap m_notificationContextMap; +#endif }; diff --git a/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.mm b/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.mm index 80138e313..2f7cd5411 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebNotificationClient.mm @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Apple Inc. All rights reserved. + * Copyright (C) 2011, 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -25,49 +25,199 @@ #import "WebNotificationClient.h" -#import <WebCore/NotImplemented.h> -#import <WebCore/Notification.h> +#if ENABLE(NOTIFICATIONS) +#import "WebDelegateImplementationCaching.h" +#import "WebNotificationInternal.h" +#import "WebPreferencesPrivate.h" +#import "WebSecurityOriginInternal.h" +#import "WebUIDelegatePrivate.h" +#import "WebViewInternal.h" +#import <WebCore/BlockExceptions.h> +#import <WebCore/Page.h> +#import <WebCore/ScriptExecutionContext.h> +#endif using namespace WebCore; +#if ENABLE(NOTIFICATIONS) +@interface WebNotificationPolicyListener : NSObject <WebAllowDenyPolicyListener> +{ + RefPtr<VoidCallback> _callback; +} +- (id)initWithCallback:(PassRefPtr<VoidCallback>)callback; +@end +#endif + +#if ENABLE(NOTIFICATIONS) +static uint64_t generateNotificationID() +{ + static uint64_t uniqueNotificationID = 1; + return uniqueNotificationID++; +} +#endif + WebNotificationClient::WebNotificationClient(WebView *webView) : m_webView(webView) { } -bool WebNotificationClient::show(Notification*) +bool WebNotificationClient::show(Notification* notification) { - notImplemented(); +#if ENABLE(NOTIFICATIONS) + if (![m_webView _notificationProvider]) + return false; + + uint64_t notificationID = generateNotificationID(); + RetainPtr<WebNotification> webNotification = adoptNS([[WebNotification alloc] initWithCoreNotification:notification notificationID:notificationID]); + m_notificationMap.set(notification, webNotification); + + NotificationContextMap::iterator it = m_notificationContextMap.add(notification->scriptExecutionContext(), Vector<RetainPtr<WebNotification> >()).first; + it->second.append(webNotification); + + [[m_webView _notificationProvider] showNotification:webNotification.get() fromWebView:m_webView]; + return true; +#else + UNUSED_PARAM(notification); return false; +#endif +} + +void WebNotificationClient::cancel(Notification* notification) +{ +#if ENABLE(NOTIFICATIONS) + WebNotification *webNotification = m_notificationMap.get(notification).get(); + if (!webNotification) + return; + + [[m_webView _notificationProvider] cancelNotification:webNotification]; +#else + UNUSED_PARAM(notification); +#endif } -void WebNotificationClient::cancel(Notification*) +void WebNotificationClient::clearNotifications(ScriptExecutionContext* context) { - notImplemented(); +#if ENABLE(NOTIFICATIONS) + NotificationContextMap::iterator it = m_notificationContextMap.find(context); + if (it == m_notificationContextMap.end()) + return; + + Vector<RetainPtr<WebNotification> >& webNotifications = it->second; + NSMutableArray *nsIDs = [NSMutableArray array]; + size_t count = webNotifications.size(); + for (size_t i = 0; i < count; ++i) { + WebNotification *webNotification = webNotifications[i].get(); + [nsIDs addObject:[NSNumber numberWithUnsignedLongLong:[webNotification notificationID]]]; + m_notificationMap.remove(core(webNotification)); + } + + [[m_webView _notificationProvider] clearNotifications:nsIDs]; + m_notificationContextMap.remove(it); +#else + UNUSED_PARAM(context); +#endif } -void WebNotificationClient::notificationObjectDestroyed(WebCore::Notification*) +void WebNotificationClient::notificationObjectDestroyed(Notification* notification) { - notImplemented(); +#if ENABLE(NOTIFICATIONS) + RetainPtr<WebNotification> webNotification = m_notificationMap.take(notification); + if (!webNotification) + return; + + NotificationContextMap::iterator it = m_notificationContextMap.find(notification->scriptExecutionContext()); + ASSERT(it != m_notificationContextMap.end()); + size_t index = it->second.find(webNotification); + ASSERT(index != notFound); + it->second.remove(index); + if (it->second.isEmpty()) + m_notificationContextMap.remove(it); + + [[m_webView _notificationProvider] notificationDestroyed:webNotification.get()]; +#else + UNUSED_PARAM(notification); +#endif } void WebNotificationClient::notificationControllerDestroyed() { +#if ENABLE(NOTIFICATIONS) + [m_webView _notificationControllerDestroyed]; +#endif delete this; } -void WebNotificationClient::requestPermission(WebCore::ScriptExecutionContext*, PassRefPtr<WebCore::VoidCallback>) +void WebNotificationClient::requestPermission(ScriptExecutionContext* context, PassRefPtr<VoidCallback> callback) { - notImplemented(); +#if ENABLE(NOTIFICATIONS) + BEGIN_BLOCK_OBJC_EXCEPTIONS; + + SEL selector = @selector(webView:decidePolicyForNotificationRequestFromOrigin:listener:); + if (![[m_webView UIDelegate] respondsToSelector:selector]) + return; + + WebSecurityOrigin *webOrigin = [[WebSecurityOrigin alloc] _initWithWebCoreSecurityOrigin:context->securityOrigin()]; + WebNotificationPolicyListener* listener = [[WebNotificationPolicyListener alloc] initWithCallback:callback]; + + CallUIDelegate(m_webView, selector, webOrigin, listener); + + [webOrigin release]; + [listener release]; + + END_BLOCK_OBJC_EXCEPTIONS; +#else + UNUSED_PARAM(context); + UNUSED_PARAM(callback); +#endif } -void WebNotificationClient::cancelRequestsForPermission(WebCore::ScriptExecutionContext*) +NotificationPresenter::Permission WebNotificationClient::checkPermission(ScriptExecutionContext* context) { - notImplemented(); +#if ENABLE(NOTIFICATIONS) + if (!context || !context->isDocument()) + return NotificationPresenter::PermissionDenied; + if (![[m_webView preferences] notificationsEnabled]) + return NotificationPresenter::PermissionDenied; + WebSecurityOrigin *webOrigin = [[WebSecurityOrigin alloc] _initWithWebCoreSecurityOrigin:context->securityOrigin()]; + WebNotificationPermission permission = [[m_webView _notificationProvider] policyForOrigin:webOrigin]; + [webOrigin release]; + switch (permission) { + case WebNotificationPermissionAllowed: + return NotificationPresenter::PermissionAllowed; + case WebNotificationPermissionDenied: + return NotificationPresenter::PermissionDenied; + case WebNotificationPermissionNotAllowed: + return NotificationPresenter::PermissionNotAllowed; + default: + return NotificationPresenter::PermissionNotAllowed; + } +#else + UNUSED_PARAM(context); + return NotificationPresenter::PermissionDenied; +#endif } -NotificationPresenter::Permission WebNotificationClient::checkPermission(WebCore::ScriptExecutionContext*) +#if ENABLE(NOTIFICATIONS) +@implementation WebNotificationPolicyListener +- (id)initWithCallback:(PassRefPtr<VoidCallback>)callback { - notImplemented(); - return NotificationPresenter::PermissionDenied; + if (!(self = [super init])) + return nil; + + ASSERT(callback); + _callback = callback; + return self; } + +- (void)allow +{ + _callback->handleEvent(); +} + +- (void)deny +{ + _callback->handleEvent(); +} + +@end +#endif diff --git a/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.h b/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.h index f1bd1a32c..4fde2b3b0 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.h +++ b/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.h @@ -27,11 +27,12 @@ #define WebPlatformStrategies_h #include <WebCore/CookiesStrategy.h> +#include <WebCore/PasteboardStrategy.h> #include <WebCore/PlatformStrategies.h> #include <WebCore/PluginStrategy.h> #include <WebCore/VisitedLinkStrategy.h> -class WebPlatformStrategies : public WebCore::PlatformStrategies, private WebCore::CookiesStrategy, private WebCore::PluginStrategy, private WebCore::VisitedLinkStrategy { +class WebPlatformStrategies : public WebCore::PlatformStrategies, private WebCore::CookiesStrategy, private WebCore::PluginStrategy, private WebCore::VisitedLinkStrategy, private WebCore::PasteboardStrategy { public: static void initialize(); @@ -42,6 +43,7 @@ private: virtual WebCore::CookiesStrategy* createCookiesStrategy() OVERRIDE; virtual WebCore::PluginStrategy* createPluginStrategy() OVERRIDE; virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy() OVERRIDE; + virtual WebCore::PasteboardStrategy* createPasteboardStrategy() OVERRIDE; // WebCore::CookiesStrategy virtual void notifyCookiesChanged() OVERRIDE; @@ -53,6 +55,22 @@ private: // WebCore::VisitedLinkStrategy virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::KURL& baseURL, const WTF::AtomicString& attributeURL) OVERRIDE; virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash) OVERRIDE; + + // WebCore::PasteboardStrategy + virtual void getTypes(Vector<String>& types, const String& pasteboardName) OVERRIDE; + virtual PassRefPtr<WebCore::SharedBuffer> bufferForType(const String& pasteboardType, const String& pasteboardName) OVERRIDE; + virtual void getPathnamesForType(Vector<String>& pathnames, const String& pasteboardType, const String& pasteboardName) OVERRIDE; + virtual String stringForType(const String& pasteboardType, const String& pasteboardName) OVERRIDE; + virtual int changeCount(const String& pasteboardName) OVERRIDE; + virtual String uniqueName() OVERRIDE; + virtual WebCore::Color color(const String& pasteboardName) OVERRIDE; + + virtual void copy(const String& fromPasteboard, const String& toPasteboard) OVERRIDE; + virtual void setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) OVERRIDE; + virtual void setBufferForType(PassRefPtr<WebCore::SharedBuffer>, const String& pasteboardType, const String& pasteboardName) OVERRIDE; + virtual void setPathnamesForType(const Vector<String>&, const String& pasteboardType, const String& pasteboardName) OVERRIDE; + virtual void setStringForType(const String&, const String& pasteboardType, const String& pasteboardName) OVERRIDE; + }; #endif // WebPlatformStrategies_h diff --git a/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.mm b/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.mm index d1a4d9560..fc3035048 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebPlatformStrategies.mm @@ -28,8 +28,10 @@ #import "WebPluginDatabase.h" #import "WebPluginPackage.h" #import <WebCore/BlockExceptions.h> +#import <WebCore/Color.h> #import <WebCore/Page.h> #import <WebCore/PageGroup.h> +#import <WebCore/PlatformPasteboard.h> using namespace WebCore; @@ -58,6 +60,11 @@ VisitedLinkStrategy* WebPlatformStrategies::createVisitedLinkStrategy() return this; } +PasteboardStrategy* WebPlatformStrategies::createPasteboardStrategy() +{ + return this; +} + void WebPlatformStrategies::notifyCookiesChanged() { } @@ -90,3 +97,63 @@ void WebPlatformStrategies::addVisitedLink(Page* page, LinkHash hash) { return page->group().addVisitedLinkHash(hash); } + +void WebPlatformStrategies::getTypes(Vector<String>& types, const String& pasteboardName) +{ + PlatformPasteboard(pasteboardName).getTypes(types); +} + +PassRefPtr<WebCore::SharedBuffer> WebPlatformStrategies::bufferForType(const String& pasteboardType, const String& pasteboardName) +{ + return PlatformPasteboard(pasteboardName).bufferForType(pasteboardType); +} + +void WebPlatformStrategies::getPathnamesForType(Vector<String>& pathnames, const String& pasteboardType, const String& pasteboardName) +{ + PlatformPasteboard(pasteboardName).getPathnamesForType(pathnames, pasteboardType); +} + +String WebPlatformStrategies::stringForType(const String& pasteboardType, const String& pasteboardName) +{ + return PlatformPasteboard(pasteboardName).stringForType(pasteboardType); +} + +void WebPlatformStrategies::copy(const String& fromPasteboard, const String& toPasteboard) +{ + PlatformPasteboard(toPasteboard).copy(fromPasteboard); +} + +int WebPlatformStrategies::changeCount(const String &pasteboardName) +{ + return PlatformPasteboard(pasteboardName).changeCount(); +} + +String WebPlatformStrategies::uniqueName() +{ + return PlatformPasteboard::uniqueName(); +} + +Color WebPlatformStrategies::color(const String& pasteboardName) +{ + return PlatformPasteboard(pasteboardName).color(); +} + +void WebPlatformStrategies::setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) +{ + PlatformPasteboard(pasteboardName).setTypes(pasteboardTypes); +} + +void WebPlatformStrategies::setBufferForType(PassRefPtr<SharedBuffer> buffer, const String& pasteboardType, const String& pasteboardName) +{ + PlatformPasteboard(pasteboardName).setBufferForType(buffer, pasteboardType); +} + +void WebPlatformStrategies::setPathnamesForType(const Vector<String>& pathnames, const String& pasteboardType, const String& pasteboardName) +{ + PlatformPasteboard(pasteboardName).setPathnamesForType(pathnames, pasteboardType); +} + +void WebPlatformStrategies::setStringForType(const String& string, const String& pasteboardType, const String& pasteboardName) +{ + PlatformPasteboard(pasteboardName).setStringForType(string, pasteboardType); +} diff --git a/Source/WebKit/mac/WebCoreSupport/WebSecurityOrigin.mm b/Source/WebKit/mac/WebCoreSupport/WebSecurityOrigin.mm index 2373f8464..8f38fed43 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebSecurityOrigin.mm +++ b/Source/WebKit/mac/WebCoreSupport/WebSecurityOrigin.mm @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2010 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2010, 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -66,6 +66,11 @@ using namespace WebCore; return reinterpret_cast<SecurityOrigin*>(_private)->databaseIdentifier(); } +- (NSString *)stringValue +{ + return reinterpret_cast<SecurityOrigin*>(_private)->toString(); +} + // Deprecated. Use host instead. This needs to stay here until we ship a new Safari. - (NSString *)domain { diff --git a/Source/WebKit/mac/WebCoreSupport/WebSecurityOriginPrivate.h b/Source/WebKit/mac/WebCoreSupport/WebSecurityOriginPrivate.h index a784aba67..fae4c3382 100644 --- a/Source/WebKit/mac/WebCoreSupport/WebSecurityOriginPrivate.h +++ b/Source/WebKit/mac/WebCoreSupport/WebSecurityOriginPrivate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2010 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2010, 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -41,6 +41,7 @@ - (NSString *)host; - (NSString *)databaseIdentifier; +- (NSString *)stringValue; // Returns zero if the port is the default port for the protocol, non-zero otherwise. - (unsigned short)port; diff --git a/Source/WebKit/mac/WebKit.order b/Source/WebKit/mac/WebKit.order index 51b31e4a9..acd1a3755 100644 --- a/Source/WebKit/mac/WebKit.order +++ b/Source/WebKit/mac/WebKit.order @@ -2308,7 +2308,6 @@ __ZN3WTF6VectorINS_6RefPtrIN7WebCore14SecurityOriginEEELm0EED1Ev -[WebStorageManager syncLocalStorage] -[WebStorageManager deleteOrigin:] -[WebStorageManager diskUsageForOrigin:] --[WebFrame(WebPrivate) _pauseSVGAnimation:onSMILNode:atTime:] __ZN3WTF6RefPtrIN7WebCore7ArchiveEED1Ev __ZN3WTF10RefCountedIN7WebCore7ArchiveEE5derefEv -[WebDataSource webArchive] diff --git a/Source/WebKit/mac/WebView/WebFrame.mm b/Source/WebKit/mac/WebView/WebFrame.mm index 9c15fafef..24bb8f39c 100644 --- a/Source/WebKit/mac/WebView/WebFrame.mm +++ b/Source/WebKit/mac/WebView/WebFrame.mm @@ -87,8 +87,6 @@ #import <WebCore/ScriptValue.h> #import <WebCore/SecurityOrigin.h> #import <WebCore/SmartReplace.h> -#import <WebCore/SVGDocumentExtensions.h> -#import <WebCore/SVGSMILElement.h> #import <WebCore/TextIterator.h> #import <WebCore/ThreadCheck.h> #import <WebCore/TypingCommand.h> @@ -801,7 +799,8 @@ static inline WebDataSource *dataSource(DocumentLoader* loader) { if (!_private->coreFrame) return; - _private->coreFrame->editor()->computeAndSetTypingStyle(core(style), undoAction); + // FIXME: We shouldn't have to create a copy here. + _private->coreFrame->editor()->computeAndSetTypingStyle(core(style)->copy().get(), undoAction); } - (void)_dragSourceEndedAt:(NSPoint)windowLoc operation:(NSDragOperation)operation @@ -992,29 +991,6 @@ static inline WebDataSource *dataSource(DocumentLoader* loader) return controller->pauseTransitionAtTime(coreNode->renderer(), name, time); } -// Pause a given SVG animation on the target node at a specific time. -// This method is only intended to be used for testing the SVG animation system. -- (BOOL)_pauseSVGAnimation:(NSString*)elementId onSMILNode:(DOMNode *)node atTime:(NSTimeInterval)time -{ -#if ENABLE(SVG) - Frame* frame = core(self); - if (!frame) - return false; - - Document* document = frame->document(); - if (!document || !document->svgExtensions()) - return false; - - Node* coreNode = core(node); - if (!coreNode || !SVGSMILElement::isSMILElement(coreNode)) - return false; - - return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time); -#else - return false; -#endif -} - - (unsigned) _numberOfActiveAnimations { Frame* frame = core(self); @@ -1484,7 +1460,7 @@ static NSURL *createUniqueWebDataURL() if (!MIMEType) MIMEType = @"text/html"; - [self _loadData:data MIMEType:MIMEType textEncodingName:encodingName baseURL:baseURL unreachableURL:nil]; + [self _loadData:data MIMEType:MIMEType textEncodingName:encodingName baseURL:[baseURL _webkit_URLFromURLOrPath] unreachableURL:nil]; } - (void)_loadHTMLString:(NSString *)string baseURL:(NSURL *)baseURL unreachableURL:(NSURL *)unreachableURL diff --git a/Source/WebKit/mac/WebView/WebFramePrivate.h b/Source/WebKit/mac/WebView/WebFramePrivate.h index 98dbb706e..899ceeddf 100644 --- a/Source/WebKit/mac/WebView/WebFramePrivate.h +++ b/Source/WebKit/mac/WebView/WebFramePrivate.h @@ -104,10 +104,6 @@ typedef enum { - (BOOL)_pauseAnimation:(NSString*)name onNode:(DOMNode *)node atTime:(NSTimeInterval)time; - (BOOL)_pauseTransitionOfProperty:(NSString*)name onNode:(DOMNode*)node atTime:(NSTimeInterval)time; -// Pause a given SVG animation on the target node at a specific time. -// This method is only intended to be used for testing the SVG animation system. -- (BOOL)_pauseSVGAnimation:(NSString*)elementId onSMILNode:(DOMNode *)node atTime:(NSTimeInterval)time; - // Returns the total number of currently running animations (includes both CSS transitions and CSS animations). - (unsigned)_numberOfActiveAnimations; diff --git a/Source/WebKit/mac/WebView/WebHTMLView.mm b/Source/WebKit/mac/WebView/WebHTMLView.mm index 66f7b3aaf..7052fca0b 100644 --- a/Source/WebKit/mac/WebView/WebHTMLView.mm +++ b/Source/WebKit/mac/WebView/WebHTMLView.mm @@ -4352,14 +4352,10 @@ static PassRefPtr<KeyboardEvent> currentKeyboardEvent(Frame* coreFrame) - (void)_applyStyleToSelection:(DOMCSSStyleDeclaration *)style withUndoAction:(EditAction)undoAction { - if (Frame* coreFrame = core([self _frame])) - coreFrame->editor()->applyStyleToSelection(core(style), undoAction); -} - -- (void)_applyParagraphStyleToSelection:(DOMCSSStyleDeclaration *)style withUndoAction:(EditAction)undoAction -{ - if (Frame* coreFrame = core([self _frame])) - coreFrame->editor()->applyParagraphStyleToSelection(core(style), undoAction); + if (Frame* coreFrame = core([self _frame])) { + // FIXME: We shouldn't have to make a copy here. We want callers of this function to work directly with StylePropertySet eventually. + coreFrame->editor()->applyStyleToSelection(core(style)->copy().get(), undoAction); + } } - (BOOL)_handleStyleKeyEquivalent:(NSEvent *)event @@ -4657,9 +4653,13 @@ static PassRefPtr<KeyboardEvent> currentKeyboardEvent(Frame* coreFrame) { DOMCSSStyleDeclaration *style = [self _styleFromColorPanelWithSelector:selector]; WebView *webView = [self _webView]; - if ([[webView _editingDelegateForwarder] webView:webView shouldApplyStyle:style toElementsInDOMRange:range]) - if (Frame* coreFrame = core([self _frame])) - coreFrame->editor()->applyStyle(core(style), [self _undoActionFromColorPanelWithSelector:selector]); + if ([[webView _editingDelegateForwarder] webView:webView shouldApplyStyle:style toElementsInDOMRange:range]) { + if (Frame* coreFrame = core([self _frame])) { + // FIXME: We shouldn't have to make a copy here. + coreFrame->editor()->applyStyle(core(style)->copy().get(), [self _undoActionFromColorPanelWithSelector:selector]); + } + } + } - (void)changeDocumentBackgroundColor:(id)sender diff --git a/Source/WebKit/mac/WebView/WebNotification.h b/Source/WebKit/mac/WebView/WebNotification.h new file mode 100644 index 000000000..c04b2ad07 --- /dev/null +++ b/Source/WebKit/mac/WebView/WebNotification.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2012 Apple Computer, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +@class WebNotificationPrivate; +@class WebSecurityOrigin; + +@interface WebNotification : NSObject +{ + WebNotificationPrivate *_private; +} + +- (NSString *)title; +- (NSString *)body; +- (WebSecurityOrigin *)origin; +- (uint64_t)notificationID; + +- (void)dispatchShowEvent; +- (void)dispatchCloseEvent; +- (void)dispatchClickEvent; +- (void)dispatchErrorEvent; + +@end diff --git a/Source/WebKit/mac/WebView/WebNotification.mm b/Source/WebKit/mac/WebView/WebNotification.mm new file mode 100644 index 000000000..bbd0248f6 --- /dev/null +++ b/Source/WebKit/mac/WebView/WebNotification.mm @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2012 Apple Computer, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#import "WebNotification.h" + +#import "WebNotificationInternal.h" + +#if ENABLE(NOTIFICATIONS) +#import "WebSecurityOriginInternal.h" +#import <WebCore/Notification.h> +#import <WebCore/ScriptExecutionContext.h> +#import <wtf/RefPtr.h> + +using namespace WebCore; +#endif + +OBJC_CLASS WebNotificationInternal; + +@interface WebNotificationPrivate : NSObject +{ +@public +#if ENABLE(NOTIFICATIONS) + RefPtr<Notification> _internal; + uint64_t _notificationID; +#endif +} +@end + +@implementation WebNotificationPrivate +@end + +#if ENABLE(NOTIFICATIONS) +@implementation WebNotification (WebNotificationInternal) +Notification* core(WebNotification *notification) +{ + if (!notification->_private) + return 0; + return notification->_private->_internal.get(); +} + +- (id)initWithCoreNotification:(Notification*)coreNotification notificationID:(uint64_t)notificationID +{ + if (!(self = [super init])) + return nil; + _private = [[WebNotificationPrivate alloc] init]; + _private->_internal = coreNotification; + _private->_notificationID = notificationID; + return self; +} +@end +#endif + +@implementation WebNotification +- (id)init +{ + return nil; +} + +- (NSString *)title +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + return core(self)->contents().title; +#else + return nil; +#endif +} + +- (NSString *)body +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + return core(self)->contents().body; +#else + return nil; +#endif +} + +- (WebSecurityOrigin *)origin +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + return [[[WebSecurityOrigin alloc] _initWithWebCoreSecurityOrigin:core(self)->scriptExecutionContext()->securityOrigin()] autorelease]; +#else + return nil; +#endif +} + +- (uint64_t)notificationID +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + return _private->_notificationID; +#else + return 0; +#endif +} + +- (void)dispatchShowEvent +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + core(self)->dispatchShowEvent(); +#endif +} + +- (void)dispatchCloseEvent +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + core(self)->dispatchCloseEvent(); +#endif +} + +- (void)dispatchClickEvent +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + core(self)->dispatchClickEvent(); +#endif +} + +- (void)dispatchErrorEvent +{ +#if ENABLE(NOTIFICATIONS) + ASSERT(core(self)); + core(self)->dispatchErrorEvent(); +#endif +} + +@end + diff --git a/Source/WebKit/mac/WebView/WebNotificationInternal.h b/Source/WebKit/mac/WebView/WebNotificationInternal.h new file mode 100644 index 000000000..b624069d9 --- /dev/null +++ b/Source/WebKit/mac/WebView/WebNotificationInternal.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2012 Apple Computer, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#import "WebNotification.h" + +#if ENABLE(NOTIFICATIONS) + +namespace WebCore { +class Notification; +} + +WebCore::Notification* core(WebNotification *); + +@interface WebNotification (WebNotificationInternal) +- (id)initWithCoreNotification:(WebCore::Notification*)coreNotification notificationID:(uint64_t)notificationID; +@end + +#endif diff --git a/Source/WebKit/mac/WebView/WebPreferenceKeysPrivate.h b/Source/WebKit/mac/WebView/WebPreferenceKeysPrivate.h index 20e42ab3d..261a30e56 100644 --- a/Source/WebKit/mac/WebView/WebPreferenceKeysPrivate.h +++ b/Source/WebKit/mac/WebView/WebPreferenceKeysPrivate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2005, 2012 Apple Computer, Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -95,6 +95,7 @@ #define WebKitCanvasUsesAcceleratedDrawingPreferenceKey @"WebKitCanvasUsesAcceleratedDrawing" #define WebKitAcceleratedCompositingEnabledPreferenceKey @"WebKitAcceleratedCompositingEnabled" #define WebKitCSSCustomFilterEnabledPreferenceKey @"WebKitCSSCustomFilterEnabled" +#define WebKitCSSRegionsEnabledPreferenceKey @"WebKitCSSRegionsEnabled" #define WebKitShowDebugBordersPreferenceKey @"WebKitShowDebugBorders" #define WebKitShowRepaintCounterPreferenceKey @"WebKitShowRepaintCounter" #define WebKitWebAudioEnabledPreferenceKey @"WebKitWebAudioEnabled" @@ -116,6 +117,8 @@ #define WebKitShouldDisplaySubtitlesPreferenceKey @"WebKitShouldDisplaySubtitles" #define WebKitShouldDisplayCaptionsPreferenceKey @"WebKitShouldDisplayCaptions" #define WebKitShouldDisplayTextDescriptionsPreferenceKey @"WebKitShouldDisplayTextDescriptions" +#define WebKitNotificationsEnabledKey @"WebKitNotificationsEnabled" +#define WebKitSuppressesIncrementalRenderingKey @"WebKitSuppressesIncrementalRendering" // These are private both because callers should be using the cover methods and because the // cover methods themselves are private. @@ -130,7 +133,6 @@ #define WebKitTextDirectionSubmenuInclusionBehaviorPreferenceKey @"WebKitTextDirectionSubmenuInclusionBehaviorPreferenceKey" #define WebKitEditingBehaviorPreferenceKey @"WebKitEditingBehavior" #define WebKitUsePreHTML5ParserQuirksKey @"WebKitUsePreHTML5ParserQuirks" -#define WebKitSuppressIncrementalRenderingKey @"WebKitSuppressIncrementalRendering" #define WebKitBackspaceKeyNavigationEnabledKey @"WebKitBackspaceKeyNavigationEnabled" // CoreGraphics deferred updates are disabled if WebKitEnableCoalescedUpdatesPreferenceKey is set diff --git a/Source/WebKit/mac/WebView/WebPreferences.h b/Source/WebKit/mac/WebView/WebPreferences.h index 80cc9355a..6e01709f0 100644 --- a/Source/WebKit/mac/WebView/WebPreferences.h +++ b/Source/WebKit/mac/WebView/WebPreferences.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2003, 2004, 2005 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2003, 2004, 2005, 2012 Apple Computer, Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -431,4 +431,17 @@ caching behavior. */ - (WebCacheModel)cacheModel; +/*! + @method setSuppressesIncrementalRendering: + @param suppressesIncrementalRendering YES to suppress incremental rendering; + NO otherwise. +*/ +- (void)setSuppressesIncrementalRendering:(BOOL)suppressesIncrementalRendering; + +/*! + @method suppressesIncrementalRendering + @result YES if the WebView suppresses incremental rendering; NO otherwise. +*/ +- (BOOL)suppressesIncrementalRendering; + @end diff --git a/Source/WebKit/mac/WebView/WebPreferences.mm b/Source/WebKit/mac/WebView/WebPreferences.mm index f49df5473..ed23910a9 100644 --- a/Source/WebKit/mac/WebView/WebPreferences.mm +++ b/Source/WebKit/mac/WebView/WebPreferences.mm @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005, 2006, 2007, 2011 Apple Inc. All rights reserved. + * Copyright (C) 2005, 2006, 2007, 2011, 2012 Apple Inc. All rights reserved. * (C) 2006 Graham Dennis (graham.dennis@gmail.com) * * Redistribution and use in source and binary forms, with or without @@ -369,6 +369,7 @@ static WebCacheModel cacheModelForMainBundle(void) [NSNumber numberWithBool:YES], WebKitAcceleratedCompositingEnabledPreferenceKey, // CSS Shaders also need WebGL enabled (which is disabled by default), so we can keep it enabled for now. [NSNumber numberWithBool:YES], WebKitCSSCustomFilterEnabledPreferenceKey, + [NSNumber numberWithBool:YES], WebKitCSSRegionsEnabledPreferenceKey, [NSNumber numberWithBool:NO], WebKitAcceleratedDrawingEnabledPreferenceKey, [NSNumber numberWithBool:NO], WebKitCanvasUsesAcceleratedDrawingPreferenceKey, [NSNumber numberWithBool:NO], WebKitShowDebugBordersPreferenceKey, @@ -384,15 +385,16 @@ static WebCacheModel cacheModelForMainBundle(void) [NSNumber numberWithBool:YES], WebKitHyperlinkAuditingEnabledPreferenceKey, [NSNumber numberWithBool:NO], WebKitUsePreHTML5ParserQuirksKey, [NSNumber numberWithBool:YES], WebKitAVFoundationEnabledKey, - [NSNumber numberWithBool:YES], WebKitHixie76WebSocketProtocolEnabledKey, + [NSNumber numberWithBool:NO], WebKitHixie76WebSocketProtocolEnabledKey, [NSNumber numberWithBool:NO], WebKitMediaPlaybackRequiresUserGesturePreferenceKey, [NSNumber numberWithBool:YES], WebKitMediaPlaybackAllowsInlinePreferenceKey, [NSNumber numberWithBool:NO], WebKitWebAudioEnabledPreferenceKey, - [NSNumber numberWithBool:NO], WebKitSuppressIncrementalRenderingKey, + [NSNumber numberWithBool:NO], WebKitSuppressesIncrementalRenderingKey, [NSNumber numberWithBool:YES], WebKitBackspaceKeyNavigationEnabledKey, [NSNumber numberWithBool:NO], WebKitShouldDisplaySubtitlesPreferenceKey, [NSNumber numberWithBool:NO], WebKitShouldDisplayCaptionsPreferenceKey, [NSNumber numberWithBool:NO], WebKitShouldDisplayTextDescriptionsPreferenceKey, + [NSNumber numberWithBool:YES], WebKitNotificationsEnabledKey, [NSNumber numberWithLongLong:ApplicationCacheStorage::noQuota()], WebKitApplicationCacheTotalQuota, [NSNumber numberWithLongLong:ApplicationCacheStorage::noQuota()], WebKitApplicationCacheDefaultOriginQuota, @@ -806,6 +808,17 @@ static WebCacheModel cacheModelForMainBundle(void) return [self _integerValueForKey:WebKitCacheModelPreferenceKey]; } + +- (void)setSuppressesIncrementalRendering:(BOOL)suppressesIncrementalRendering +{ + [self _setBoolValue:suppressesIncrementalRendering forKey:WebKitSuppressesIncrementalRenderingKey]; +} + +- (BOOL)suppressesIncrementalRendering +{ + return [self _boolValueForKey:WebKitSuppressesIncrementalRenderingKey]; +} + @end @implementation WebPreferences (WebPrivate) @@ -1335,6 +1348,16 @@ static NSString *classIBCreatorID = nil; [self _setBoolValue:enabled forKey:WebKitCSSCustomFilterEnabledPreferenceKey]; } +- (BOOL)cssRegionsEnabled +{ + return [self _boolValueForKey:WebKitCSSRegionsEnabledPreferenceKey]; +} + +- (void)setCSSRegionsEnabled:(BOOL)enabled +{ + [self _setBoolValue:enabled forKey:WebKitCSSRegionsEnabledPreferenceKey]; +} + - (BOOL)showDebugBorders { return [self _boolValueForKey:WebKitShowDebugBordersPreferenceKey]; @@ -1583,12 +1606,12 @@ static NSString *classIBCreatorID = nil; - (void)setSuppressIncrementalRendering:(BOOL)flag { - [self _setBoolValue:flag forKey:WebKitSuppressIncrementalRenderingKey]; + [self _setBoolValue:flag forKey:WebKitSuppressesIncrementalRenderingKey]; } - (BOOL)suppressIncrementalRendering { - return [self _boolValueForKey:WebKitSuppressIncrementalRenderingKey]; + return [self _boolValueForKey:WebKitSuppressesIncrementalRenderingKey]; } - (void)setBackspaceKeyNavigationEnabled:(BOOL)flag @@ -1631,6 +1654,16 @@ static NSString *classIBCreatorID = nil; return [self _boolValueForKey:WebKitShouldDisplayTextDescriptionsPreferenceKey]; } +- (void)setNotificationsEnabled:(BOOL)flag +{ + [self _setBoolValue:flag forKey:WebKitNotificationsEnabledKey]; +} + +- (BOOL)notificationsEnabled +{ + return [self _boolValueForKey:WebKitNotificationsEnabledKey]; +} + @end @implementation WebPreferences (WebInternal) diff --git a/Source/WebKit/mac/WebView/WebPreferencesPrivate.h b/Source/WebKit/mac/WebView/WebPreferencesPrivate.h index 305434ffb..29a8be125 100644 --- a/Source/WebKit/mac/WebView/WebPreferencesPrivate.h +++ b/Source/WebKit/mac/WebView/WebPreferencesPrivate.h @@ -189,6 +189,9 @@ extern NSString *WebPreferencesChangedInternalNotification; - (BOOL)cssCustomFilterEnabled; - (void)setCSSCustomFilterEnabled:(BOOL)enabled; +- (BOOL)cssRegionsEnabled; +- (void)setCSSRegionsEnabled:(BOOL)enabled; + - (BOOL)showDebugBorders; - (void)setShowDebugBorders:(BOOL)show; @@ -271,6 +274,7 @@ extern NSString *WebPreferencesChangedInternalNotification; - (void)setHixie76WebSocketProtocolEnabled:(BOOL)flag; - (BOOL)isHixie76WebSocketProtocolEnabled; +// Deprecated. You should use [setS|s]uppressesIncrementalRendering in WebPreferences.h instead. - (void)setSuppressIncrementalRendering:(BOOL)flag; - (BOOL)suppressIncrementalRendering; @@ -286,4 +290,7 @@ extern NSString *WebPreferencesChangedInternalNotification; - (void)setShouldDisplayTextDescriptions:(BOOL)flag; - (BOOL)shouldDisplayTextDescriptions; +- (void)setNotificationsEnabled:(BOOL)flag; +- (BOOL)notificationsEnabled; + @end diff --git a/Source/WebKit/mac/WebView/WebUIDelegatePrivate.h b/Source/WebKit/mac/WebView/WebUIDelegatePrivate.h index 9c98fdfcc..9f1801961 100644 --- a/Source/WebKit/mac/WebView/WebUIDelegatePrivate.h +++ b/Source/WebKit/mac/WebView/WebUIDelegatePrivate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved. + * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -117,9 +117,11 @@ extern NSString *WebConsoleMessageWarningMessageLevel; extern NSString *WebConsoleMessageErrorMessageLevel; extern NSString *WebConsoleMessageDebugMessageLevel; +@class DOMElement; +@class DOMNode; @class WebSecurityOrigin; -@protocol WebGeolocationPolicyListener <NSObject> +@protocol WebAllowDenyPolicyListener <NSObject> - (void)allow; - (void)deny; @end @@ -223,7 +225,8 @@ extern NSString *WebConsoleMessageDebugMessageLevel; */ - (void)webView:(WebView *)webView decidePolicyForGeolocationRequestFromOrigin:(WebSecurityOrigin *)origin frame:(WebFrame *)frame - listener:(id<WebGeolocationPolicyListener>)listener; + listener:(id<WebAllowDenyPolicyListener>)listener; +- (void)webView:(WebView *)webView decidePolicyForNotificationRequestFromOrigin:(WebSecurityOrigin *)origin listener:(id<WebAllowDenyPolicyListener>)listener; - (void)webView:(WebView *)sender elementDidFocusNode:(DOMNode *)node; - (void)webView:(WebView *)sender elementDidBlurNode:(DOMNode *)node; diff --git a/Source/WebKit/mac/WebView/WebView.mm b/Source/WebKit/mac/WebView/WebView.mm index 4525cba9f..9b722026e 100644 --- a/Source/WebKit/mac/WebView/WebView.mm +++ b/Source/WebKit/mac/WebView/WebView.mm @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. + * Copyright (C) 2005-2012 Apple Inc. All rights reserved. * Copyright (C) 2006 David Smith (catfish.man@gmail.com) * Copyright (C) 2010 Igalia S.L * @@ -742,13 +742,13 @@ static NSString *leakOutlookQuirksUserScriptContents() #if ENABLE(CLIENT_BASED_GEOLOCATION) pageClients.geolocationClient = new WebGeolocationClient(self); #endif + _private->page = new Page(pageClients); #if ENABLE(NOTIFICATIONS) - pageClients.notificationClient = new WebNotificationClient(self); + WebCore::provideNotification(_private->page, new WebNotificationClient(self)); #endif #if ENABLE(DEVICE_ORIENTATION) - pageClients.deviceOrientationClient = new WebDeviceOrientationClient(self); + WebCore::provideDeviceOrientationTo(_private->page, new WebDeviceOrientationClient(self)); #endif - _private->page = new Page(pageClients); _private->page->setCanStartMedia([self window]); _private->page->settings()->setLocalStorageDatabasePath([[self preferences] _localStorageDatabasePath]); @@ -1322,6 +1322,13 @@ static bool fastDocumentTeardownEnabled() return needsQuirk; } +- (BOOL)_needsIsLoadingInAPISenseQuirk +{ + static BOOL needsQuirk = WKAppVersionCheckLessThan(@"com.apple.iAdProducer", -1, 2.1); + + return needsQuirk; +} + - (BOOL)_needsKeyboardEventDisambiguationQuirks { static BOOL needsQuirks = !WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_IE_COMPATIBLE_KEYBOARD_EVENT_DISPATCH) && !applicationIsSafari(); @@ -1474,6 +1481,7 @@ static bool needsSelfRetainWhileLoadingQuirk() #if ENABLE(CSS_SHADERS) settings->setCSSCustomFilterEnabled([preferences cssCustomFilterEnabled]); #endif + settings->setCSSRegionsEnabled([preferences cssRegionsEnabled]); #if ENABLE(FULLSCREEN_API) settings->setFullScreenEnabled([preferences fullScreenEnabled]); #endif @@ -1499,7 +1507,7 @@ static bool needsSelfRetainWhileLoadingQuirk() #endif settings->setMediaPlaybackRequiresUserGesture([preferences mediaPlaybackRequiresUserGesture]); settings->setMediaPlaybackAllowsInline([preferences mediaPlaybackAllowsInline]); - settings->setSuppressIncrementalRendering([preferences suppressIncrementalRendering]); + settings->setSuppressesIncrementalRendering([preferences suppressesIncrementalRendering]); settings->setBackspaceKeyNavigationEnabled([preferences backspaceKeyNavigationEnabled]); settings->setMockScrollbarsEnabled([preferences mockScrollbarsEnabled]); @@ -1509,6 +1517,8 @@ static bool needsSelfRetainWhileLoadingQuirk() settings->setShouldDisplayTextDescriptions([preferences shouldDisplayTextDescriptions]); #endif + settings->setNeedsIsLoadingInAPISenseQuirk([self _needsIsLoadingInAPISenseQuirk]); + // Application Cache Preferences are stored on the global cache storage manager, not in Settings. [WebApplicationCache setDefaultOriginQuota:[preferences applicationCacheDefaultOriginQuota]]; @@ -5516,8 +5526,9 @@ static NSAppleEventDescriptor* aeDescFromJSValue(ExecState* exec, JSValue jsValu // change the API to allow this. WebFrame *webFrame = [self _selectedOrMainFrame]; Frame* coreFrame = core(webFrame); + // FIXME: We shouldn't have to make a copy here. if (coreFrame) - coreFrame->editor()->applyStyle(core(style)); + coreFrame->editor()->applyStyle(core(style)->copy().get()); } @end @@ -6401,6 +6412,43 @@ static void glibContextIterationCallback(CFRunLoopObserverRef, CFRunLoopActivity @end +@implementation WebView (WebViewNotification) +- (void)_setNotificationProvider:(id<WebNotificationProvider>)notificationProvider +{ + if (_private) { + _private->_notificationProvider = notificationProvider; + [_private->_notificationProvider registerWebView:self]; + } +} + +- (void)_notificationControllerDestroyed +{ + [[self _notificationProvider] unregisterWebView:self]; +} + +- (id<WebNotificationProvider>)_notificationProvider +{ + if (_private) + return _private->_notificationProvider; + return nil; +} + +- (void)_notificationDidShow:(uint64_t)notificationID +{ + [[self _notificationProvider] webView:self didShowNotification:notificationID]; +} + +- (void)_notificationDidClick:(uint64_t)notificationID +{ + [[self _notificationProvider] webView:self didClickNotification:notificationID]; +} + +- (void)_notificationsDidClose:(NSArray *)notificationIDs +{ + [[self _notificationProvider] webView:self didCloseNotifications:notificationIDs]; +} +@end + @implementation WebView (WebViewPrivateStyleInfo) - (JSValueRef)_computedStyleIncludingVisitedInfo:(JSContextRef)context forElement:(JSValueRef)value @@ -6414,7 +6462,7 @@ static void glibContextIterationCallback(CFRunLoopObserverRef, CFRunLoopActivity return JSValueMakeUndefined(context); JSElement* jsElement = static_cast<JSElement*>(asObject(jsValue)); Element* element = jsElement->impl(); - RefPtr<CSSComputedStyleDeclaration> style = computedStyle(element, true); + RefPtr<CSSComputedStyleDeclaration> style = CSSComputedStyleDeclaration::create(element, true); return toRef(exec, toJS(exec, jsElement->globalObject(), style.get())); } diff --git a/Source/WebKit/mac/WebView/WebViewData.h b/Source/WebKit/mac/WebView/WebViewData.h index 665cb9175..ea2bfcf60 100644 --- a/Source/WebKit/mac/WebView/WebViewData.h +++ b/Source/WebKit/mac/WebView/WebViewData.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. + * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved. * Copyright (C) 2010 Igalia S.L * * Redistribution and use in source and binary forms, with or without @@ -50,6 +50,7 @@ namespace WebCore { @protocol WebFormDelegate; @protocol WebDeviceOrientationProvider; @protocol WebGeolocationProvider; +@protocol WebNotificationProvider; #if ENABLE(VIDEO) @class WebVideoFullscreenController; #endif @@ -191,6 +192,7 @@ private: #endif id<WebGeolocationProvider> _geolocationProvider; id<WebDeviceOrientationProvider> m_deviceOrientationProvider; + id<WebNotificationProvider> _notificationProvider; RefPtr<WebCore::HistoryItem> _globalHistoryItem; diff --git a/Source/WebKit/mac/WebView/WebViewPrivate.h b/Source/WebKit/mac/WebView/WebViewPrivate.h index cd92f31e5..e0fee81d1 100644 --- a/Source/WebKit/mac/WebView/WebViewPrivate.h +++ b/Source/WebKit/mac/WebView/WebViewPrivate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. + * Copyright (C) 2005-2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -39,8 +39,10 @@ @class WebDeviceOrientation; @class WebGeolocationPosition; @class WebInspector; +@class WebNotification; @class WebPreferences; @class WebScriptWorld; +@class WebSecurityOrigin; @class WebTextIterator; @protocol WebDeviceOrientationProvider; @@ -104,6 +106,13 @@ typedef enum { WebPaginationModeVertical, } WebPaginationMode; +// This needs to be in sync with WebCore::NotificationPresenter::Permission +typedef enum { + WebNotificationPermissionAllowed, + WebNotificationPermissionNotAllowed, + WebNotificationPermissionDenied +} WebNotificationPermission; + @interface WebController : NSTreeController { IBOutlet WebView *webView; } @@ -701,6 +710,21 @@ Could be worth adding to the API. - (WebGeolocationPosition *)lastPosition; @end +@protocol WebNotificationProvider +- (void)registerWebView:(WebView *)webView; +- (void)unregisterWebView:(WebView *)webView; + +- (void)showNotification:(WebNotification *)notification fromWebView:(WebView *)webView; +- (void)cancelNotification:(WebNotification *)notification; +- (void)notificationDestroyed:(WebNotification *)notification; +- (void)clearNotifications:(NSArray *)notificationIDs; +- (WebNotificationPermission)policyForOrigin:(WebSecurityOrigin *)origin; + +- (void)webView:(WebView *)webView didShowNotification:(uint64_t)notificationID; +- (void)webView:(WebView *)webView didClickNotification:(uint64_t)notificationID; +- (void)webView:(WebView *)webView didCloseNotifications:(NSArray *)notificationIDs; +@end + @interface WebView (WebViewGeolocation) - (void)_setGeolocationProvider:(id<WebGeolocationProvider>)locationProvider; - (id<WebGeolocationProvider>)_geolocationProvider; @@ -709,6 +733,16 @@ Could be worth adding to the API. - (void)_geolocationDidFailWithError:(NSError *)error; @end +@interface WebView (WebViewNotification) +- (void)_setNotificationProvider:(id<WebNotificationProvider>)notificationProvider; +- (id<WebNotificationProvider>)_notificationProvider; +- (void)_notificationControllerDestroyed; + +- (void)_notificationDidShow:(uint64_t)notificationID; +- (void)_notificationDidClick:(uint64_t)notificationID; +- (void)_notificationsDidClose:(NSArray *)notificationIDs; +@end + @interface WebView (WebViewPrivateStyleInfo) - (JSValueRef)_computedStyleIncludingVisitedInfo:(JSContextRef)context forElement:(JSValueRef)value; @end diff --git a/Source/WebKit/qt/Api/qgraphicswebview.cpp b/Source/WebKit/qt/Api/qgraphicswebview.cpp index c1eb5293a..3f6fe1471 100644 --- a/Source/WebKit/qt/Api/qgraphicswebview.cpp +++ b/Source/WebKit/qt/Api/qgraphicswebview.cpp @@ -288,13 +288,13 @@ void QGraphicsWebView::paint(QPainter* painter, const QStyleOptionGraphicsItem* #if USE(TILED_BACKING_STORE) if (WebCore::TiledBackingStore* backingStore = QWebFramePrivate::core(page()->mainFrame())->tiledBackingStore()) { // FIXME: We should set the backing store viewport earlier than in paint - backingStore->adjustVisibleRect(); + backingStore->coverWithTilesIfNeeded(); // QWebFrame::render is a public API, bypass it for tiled rendering so behavior does not need to change. - WebCore::GraphicsContext context(painter); + WebCore::GraphicsContext context(painter); page()->mainFrame()->d->renderFromTiledBackingStore(&context, option->exposedRect.toAlignedRect()); painter->setRenderHints(oldHints); return; - } + } #endif #if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER) page()->mainFrame()->render(painter, d->overlay() ? QWebFrame::ContentsLayer : QWebFrame::AllLayers, option->exposedRect.toAlignedRect()); @@ -312,7 +312,11 @@ bool QGraphicsWebView::sceneEvent(QEvent* event) if (d->page && (event->type() == QEvent::TouchBegin || event->type() == QEvent::TouchEnd - || event->type() == QEvent::TouchUpdate)) { + || event->type() == QEvent::TouchUpdate +#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) + || event->type() == QEvent::TouchCancel +#endif + )) { d->page->event(event); // Always return true so that we'll receive also TouchUpdate and TouchEnd events diff --git a/Source/WebKit/qt/Api/qwebelement.cpp b/Source/WebKit/qt/Api/qwebelement.cpp index 178c70e5b..40c69f4bf 100644 --- a/Source/WebKit/qt/Api/qwebelement.cpp +++ b/Source/WebKit/qt/Api/qwebelement.cpp @@ -882,7 +882,7 @@ QString QWebElement::styleProperty(const QString &name, StyleResolveStrategy str int propID = cssPropertyID(name); - RefPtr<CSSComputedStyleDeclaration> style = computedStyle(m_element, true); + RefPtr<CSSComputedStyleDeclaration> style = CSSComputedStyleDeclaration::create(m_element, true); if (!propID || !style) return QString(); diff --git a/Source/WebKit/qt/Api/qwebframe.cpp b/Source/WebKit/qt/Api/qwebframe.cpp index 39b9d20d4..211f0ef20 100644 --- a/Source/WebKit/qt/Api/qwebframe.cpp +++ b/Source/WebKit/qt/Api/qwebframe.cpp @@ -104,7 +104,7 @@ #endif #if USE(TEXTURE_MAPPER) #include "texmap/TextureMapper.h" -#include "texmap/TextureMapperNode.h" +#include "texmap/TextureMapperLayer.h" #endif #include "wtf/HashMap.h" #include <QMultiMap> @@ -331,7 +331,7 @@ void QWebFramePrivate::renderFromTiledBackingStore(GraphicsContext* context, con #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) void QWebFramePrivate::renderCompositedLayers(GraphicsContext* context, const IntRect& clip) { - if (!rootTextureMapperNode || !textureMapper) + if (!rootTextureMapperLayer || !textureMapper) return; textureMapper->setGraphicsContext(context); @@ -345,11 +345,11 @@ void QWebFramePrivate::renderCompositedLayers(GraphicsContext* context, const In 0, 0, 1, 0, transform.m31(), transform.m32(), 0, transform.m33() ); - rootTextureMapperNode->setTransform(matrix); - rootTextureMapperNode->setOpacity(painter->opacity()); + rootTextureMapperLayer->setTransform(matrix); + rootTextureMapperLayer->setOpacity(painter->opacity()); textureMapper->beginPainting(); textureMapper->beginClip(matrix, clip); - rootTextureMapperNode->paint(); + rootTextureMapperLayer->paint(); textureMapper->endClip(); textureMapper->endPainting(); } diff --git a/Source/WebKit/qt/Api/qwebframe.h b/Source/WebKit/qt/Api/qwebframe.h index 35fce4beb..ff157771f 100644 --- a/Source/WebKit/qt/Api/qwebframe.h +++ b/Source/WebKit/qt/Api/qwebframe.h @@ -60,7 +60,7 @@ namespace WebCore { class WidgetPrivate; class FrameLoaderClientQt; class ChromeClientQt; - class TextureMapperNodeClientQt; + class TextureMapperLayerClientQt; } class QWebFrameData; class QWebHitTestResultPrivate; @@ -234,7 +234,7 @@ private: friend class WebCore::WidgetPrivate; friend class WebCore::FrameLoaderClientQt; friend class WebCore::ChromeClientQt; - friend class WebCore::TextureMapperNodeClientQt; + friend class WebCore::TextureMapperLayerClientQt; QWebFramePrivate *d; Q_PRIVATE_SLOT(d, void _q_orientationChanged()) }; diff --git a/Source/WebKit/qt/Api/qwebframe_p.h b/Source/WebKit/qt/Api/qwebframe_p.h index 1dba6a59e..4ab7b9700 100644 --- a/Source/WebKit/qt/Api/qwebframe_p.h +++ b/Source/WebKit/qt/Api/qwebframe_p.h @@ -49,7 +49,7 @@ namespace WebCore { class FrameView; class HTMLFrameOwnerElement; class Scrollbar; - class TextureMapperNode; + class TextureMapperLayer; } class QWebPage; @@ -85,7 +85,7 @@ public: , marginWidth(-1) , marginHeight(-1) #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) - , rootTextureMapperNode(0) + , rootTextureMapperLayer(0) #endif {} void init(QWebFrame* qframe, QWebFrameData* frameData); @@ -125,7 +125,7 @@ public: int marginWidth; int marginHeight; #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) - WebCore::TextureMapperNode* rootTextureMapperNode; + WebCore::TextureMapperLayer* rootTextureMapperLayer; OwnPtr<WebCore::TextureMapper> textureMapper; #endif diff --git a/Source/WebKit/qt/Api/qwebpage.cpp b/Source/WebKit/qt/Api/qwebpage.cpp index f94d44589..898899bf5 100644 --- a/Source/WebKit/qt/Api/qwebpage.cpp +++ b/Source/WebKit/qt/Api/qwebpage.cpp @@ -105,6 +105,7 @@ #include "RenderThemeQt.h" #include "SchemeRegistry.h" #include "Scrollbar.h" +#include "ScrollbarTheme.h" #include "SecurityOrigin.h" #include "Settings.h" #if defined Q_OS_WIN32 @@ -112,9 +113,11 @@ #endif // Q_OS_WIN32 #include "TextIterator.h" #include "UtilsQt.h" +#include "WebEventConversion.h" #include "WindowFeatures.h" #include "WorkerThread.h" +#include <QAction> #include <QApplication> #include <QBasicTimer> #include <QBitArray> @@ -126,6 +129,7 @@ #include <QDropEvent> #include <QFileDialog> #include <QInputDialog> +#include <QMenu> #include <QMessageBox> #include <QNetworkProxy> #include <QUndoStack> @@ -322,24 +326,23 @@ QWebPagePrivate::QWebPagePrivate(QWebPage *qq) pageClients.editorClient = new EditorClientQt(q); pageClients.dragClient = new DragClientQt(q); pageClients.inspectorClient = new InspectorClientQt(q); -#if ENABLE(DEVICE_ORIENTATION) - if (useMock) - pageClients.deviceOrientationClient = new DeviceOrientationClientMock; - else - pageClients.deviceOrientationClient = new DeviceOrientationClientQt; - - pageClients.deviceMotionClient = new DeviceMotionClientQt; -#endif #if ENABLE(CLIENT_BASED_GEOLOCATION) if (useMock) pageClients.geolocationClient = new GeolocationClientMock; else pageClients.geolocationClient = new GeolocationClientQt(q); #endif + page = new Page(pageClients); +#if ENABLE(DEVICE_ORIENTATION) + if (useMock) + WebCore::provideDeviceOrientationTo(page, new DeviceOrientationClientMock); + else + WebCore::provideDeviceOrientationTo(page, new DeviceOrientationClientQt); + WebCore::provideDeviceMotionTo(page, new DeviceMotionClientQt); +#endif #if ENABLE(NOTIFICATIONS) - pageClients.notificationClient = NotificationPresenterClientQt::notificationPresenter(); + WebCore::provideNotification(page, NotificationPresenterClientQt::notificationPresenter()); #endif - page = new Page(pageClients); // By default each page is put into their own unique page group, which affects popup windows // and visited links. Page groups (per process only) is a feature making it possible to use @@ -677,7 +680,7 @@ void QWebPagePrivate::mouseMoveEvent(T* ev) if (!frame->view()) return; - bool accepted = frame->eventHandler()->mouseMoved(PlatformMouseEvent(ev, 0)); + bool accepted = frame->eventHandler()->mouseMoved(convertMouseEvent(ev, 0)); ev->setAccepted(accepted); } @@ -702,7 +705,7 @@ void QWebPagePrivate::mousePressEvent(T* ev) bool accepted = false; adjustPointForClicking(ev); - PlatformMouseEvent mev(ev, 1); + PlatformMouseEvent mev = convertMouseEvent(ev, 1); // ignore the event if we can't map Qt's mouse buttons to WebCore::MouseButton if (mev.button() != NoButton) accepted = frame->eventHandler()->handleMousePressEvent(mev); @@ -725,7 +728,7 @@ void QWebPagePrivate::mouseDoubleClickEvent(T *ev) return; bool accepted = false; - PlatformMouseEvent mev(ev, 2); + PlatformMouseEvent mev = convertMouseEvent(ev, 2); // ignore the event if we can't map Qt's mouse buttons to WebCore::MouseButton if (mev.button() != NoButton) accepted = frame->eventHandler()->handleMousePressEvent(mev); @@ -743,7 +746,7 @@ void QWebPagePrivate::mouseTripleClickEvent(T *ev) return; bool accepted = false; - PlatformMouseEvent mev(ev, 3); + PlatformMouseEvent mev = convertMouseEvent(ev, 3); // ignore the event if we can't map Qt's mouse buttons to WebCore::MouseButton if (mev.button() != NoButton) accepted = frame->eventHandler()->handleMousePressEvent(mev); @@ -782,7 +785,7 @@ void QWebPagePrivate::mouseReleaseEvent(T *ev) bool accepted = false; adjustPointForClicking(ev); - PlatformMouseEvent mev(ev, 0); + PlatformMouseEvent mev = convertMouseEvent(ev, 0); // ignore the event if we can't map Qt's mouse buttons to WebCore::MouseButton if (mev.button() != NoButton) accepted = frame->eventHandler()->handleMouseReleaseEvent(mev); @@ -852,7 +855,7 @@ void QWebPagePrivate::wheelEvent(T *ev) if (!frame->view()) return; - WebCore::PlatformWheelEvent pev(ev); + PlatformWheelEvent pev = convertWheelEvent(ev); bool accepted = frame->eventHandler()->handleWheelEvent(pev); ev->setAccepted(accepted); } @@ -1199,43 +1202,6 @@ void QWebPagePrivate::dynamicPropertyChangeEvent(QDynamicPropertyChangeEvent* ev } } } -#if USE(TILED_BACKING_STORE) - else if (event->propertyName() == "_q_TiledBackingStoreTileSize") { - WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame()); - if (!frame->tiledBackingStore()) - return; - QSize tileSize = q->property("_q_TiledBackingStoreTileSize").toSize(); - frame->tiledBackingStore()->setTileSize(tileSize); - } else if (event->propertyName() == "_q_TiledBackingStoreTileCreationDelay") { - WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame()); - if (!frame->tiledBackingStore()) - return; - int tileCreationDelay = q->property("_q_TiledBackingStoreTileCreationDelay").toInt(); - frame->tiledBackingStore()->setTileCreationDelay(static_cast<double>(tileCreationDelay) / 1000.); - } else if (event->propertyName() == "_q_TiledBackingStoreKeepAreaMultiplier") { - WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame()); - if (!frame->tiledBackingStore()) - return; - float keepMultiplier; - float coverMultiplier; - frame->tiledBackingStore()->getKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier); - QSizeF qSize = q->property("_q_TiledBackingStoreKeepAreaMultiplier").toSizeF(); - // setKeepAndCoverAreaMultipliers do not use FloatSize anymore, keep only the height part. - keepMultiplier = qSize.height(); - frame->tiledBackingStore()->setKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier); - } else if (event->propertyName() == "_q_TiledBackingStoreCoverAreaMultiplier") { - WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame()); - if (!frame->tiledBackingStore()) - return; - float keepMultiplier; - float coverMultiplier; - frame->tiledBackingStore()->getKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier); - QSizeF qSize = q->property("_q_TiledBackingStoreCoverAreaMultiplier").toSizeF(); - // setKeepAndCoverAreaMultipliers do not use FloatSize anymore, keep only the height part. - coverMultiplier = qSize.height(); - frame->tiledBackingStore()->setKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier); - } -#endif else if (event->propertyName() == "_q_webInspectorServerPort") { InspectorServerQt* inspectorServer = InspectorServerQt::server(); inspectorServer->listen(inspectorServerPort()); @@ -1566,7 +1532,7 @@ static bool isClickableElement(Element* element, RefPtr<NodeList> list) ExceptionCode ec = 0; return isClickable || element->webkitMatchesSelector("a,*:link,*:visited,*[role=button],button,input,select,label", ec) - || computedStyle(element)->getPropertyValue(cssPropertyID("cursor")) == "pointer"; + || CSSComputedStyleDeclaration::create(element)->getPropertyValue(cssPropertyID("cursor")) == "pointer"; } static bool isValidFrameOwner(Element* element) @@ -3150,6 +3116,9 @@ bool QWebPage::event(QEvent *ev) case QEvent::TouchBegin: case QEvent::TouchUpdate: case QEvent::TouchEnd: +#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) + case QEvent::TouchCancel: +#endif // Return whether the default action was cancelled in the JS event handler return d->touchEvent(static_cast<QTouchEvent*>(ev)); #ifndef QT_NO_PROPERTIES @@ -3259,6 +3228,55 @@ QWebPage::LinkDelegationPolicy QWebPage::linkDelegationPolicy() const } #ifndef QT_NO_CONTEXTMENU + +static bool handleScrollbarContextMenuEvent(Scrollbar* scrollBar, QContextMenuEvent* event) +{ + if (!QApplication::style()->styleHint(QStyle::SH_ScrollBar_ContextMenu)) + return true; + + bool horizontal = (scrollBar->orientation() == HorizontalScrollbar); + + QMenu menu; + QAction* actScrollHere = menu.addAction(QCoreApplication::translate("QWebPage", "Scroll here")); + menu.addSeparator(); + + QAction* actScrollTop = menu.addAction(horizontal ? QCoreApplication::translate("QWebPage", "Left edge") : QCoreApplication::translate("QWebPage", "Top")); + QAction* actScrollBottom = menu.addAction(horizontal ? QCoreApplication::translate("QWebPage", "Right edge") : QCoreApplication::translate("QWebPage", "Bottom")); + menu.addSeparator(); + + QAction* actPageUp = menu.addAction(horizontal ? QCoreApplication::translate("QWebPage", "Page left") : QCoreApplication::translate("QWebPage", "Page up")); + QAction* actPageDown = menu.addAction(horizontal ? QCoreApplication::translate("QWebPage", "Page right") : QCoreApplication::translate("QWebPage", "Page down")); + menu.addSeparator(); + + QAction* actScrollUp = menu.addAction(horizontal ? QCoreApplication::translate("QWebPage", "Scroll left") : QCoreApplication::translate("QWebPage", "Scroll up")); + QAction* actScrollDown = menu.addAction(horizontal ? QCoreApplication::translate("QWebPage", "Scroll right") : QCoreApplication::translate("QWebPage", "Scroll down")); + + QAction* actionSelected = menu.exec(event->globalPos()); + + if (actionSelected == actScrollHere) { + ScrollbarTheme* theme = scrollBar->theme(); + // Set the pressed position to the middle of the thumb so that when we + // do move, the delta will be from the current pixel position of the + // thumb to the new position + int position = theme->trackPosition(scrollBar) + theme->thumbPosition(scrollBar) + theme->thumbLength(scrollBar) / 2; + scrollBar->setPressedPos(position); + const QPoint pos = scrollBar->convertFromContainingWindow(event->pos()); + scrollBar->moveThumb(horizontal ? pos.x() : pos.y()); + } else if (actionSelected == actScrollTop) + scrollBar->scrollableArea()->scroll(horizontal ? ScrollLeft : ScrollUp, ScrollByDocument); + else if (actionSelected == actScrollBottom) + scrollBar->scrollableArea()->scroll(horizontal ? ScrollRight : ScrollDown, ScrollByDocument); + else if (actionSelected == actPageUp) + scrollBar->scrollableArea()->scroll(horizontal ? ScrollLeft : ScrollUp, ScrollByPage); + else if (actionSelected == actPageDown) + scrollBar->scrollableArea()->scroll(horizontal ? ScrollRight : ScrollDown, ScrollByPage); + else if (actionSelected == actScrollUp) + scrollBar->scrollableArea()->scroll(horizontal ? ScrollLeft : ScrollUp, ScrollByLine); + else if (actionSelected == actScrollDown) + scrollBar->scrollableArea()->scroll(horizontal ? ScrollRight : ScrollDown, ScrollByLine); + return true; +} + /*! Filters the context menu event, \a event, through handlers for scrollbars and custom event handlers in the web page. Returns true if the event was handled; @@ -3276,14 +3294,14 @@ bool QWebPage::swallowContextMenuEvent(QContextMenuEvent *event) if (!RenderThemeQt::useMobileTheme()) { if (QWebFrame* webFrame = frameAt(event->pos())) { Frame* frame = QWebFramePrivate::core(webFrame); - if (Scrollbar* scrollbar = frame->view()->scrollbarAtPoint(PlatformMouseEvent(event, 1).position())) - return scrollbar->contextMenu(PlatformMouseEvent(event, 1)); + if (Scrollbar* scrollbar = frame->view()->scrollbarAtPoint(convertMouseEvent(event, 1).position())) + return handleScrollbarContextMenuEvent(scrollbar, event); } } #endif WebCore::Frame* focusedFrame = d->page->focusController()->focusedOrMainFrame(); - focusedFrame->eventHandler()->sendContextMenuEvent(PlatformMouseEvent(event, 1)); + focusedFrame->eventHandler()->sendContextMenuEvent(convertMouseEvent(event, 1)); ContextMenu *menu = d->page->contextMenuController()->contextMenu(); // If the website defines its own handler then sendContextMenuEvent takes care of // calling/showing it and the context menu pointer will be zero. This is the case diff --git a/Source/WebKit/qt/Api/qwebsettings.cpp b/Source/WebKit/qt/Api/qwebsettings.cpp index 89e982140..2885f01ee 100644 --- a/Source/WebKit/qt/Api/qwebsettings.cpp +++ b/Source/WebKit/qt/Api/qwebsettings.cpp @@ -171,6 +171,10 @@ void QWebSettingsPrivate::apply() #endif #endif + value = attributes.value(QWebSettings::CSSRegionsEnabled, + global->attributes.value(QWebSettings::CSSRegionsEnabled)); + settings->setCSSRegionsEnabled(value); + value = attributes.value(QWebSettings::HyperlinkAuditingEnabled, global->attributes.value(QWebSettings::HyperlinkAuditingEnabled)); @@ -515,6 +519,7 @@ QWebSettings::QWebSettings() d->attributes.insert(QWebSettings::LocalContentCanAccessFileUrls, true); d->attributes.insert(QWebSettings::AcceleratedCompositingEnabled, true); d->attributes.insert(QWebSettings::WebGLEnabled, false); + d->attributes.insert(QWebSettings::CSSRegionsEnabled, false); d->attributes.insert(QWebSettings::HyperlinkAuditingEnabled, false); d->attributes.insert(QWebSettings::TiledBackingStoreEnabled, false); d->attributes.insert(QWebSettings::FrameFlatteningEnabled, false); diff --git a/Source/WebKit/qt/Api/qwebsettings.h b/Source/WebKit/qt/Api/qwebsettings.h index 40f7f73f9..136ee8dc4 100644 --- a/Source/WebKit/qt/Api/qwebsettings.h +++ b/Source/WebKit/qt/Api/qwebsettings.h @@ -81,6 +81,7 @@ public: SiteSpecificQuirksEnabled, JavascriptCanCloseWindows, WebGLEnabled, + CSSRegionsEnabled, HyperlinkAuditingEnabled }; enum WebGraphic { diff --git a/Source/WebKit/qt/Api/qwebview.cpp b/Source/WebKit/qt/Api/qwebview.cpp index 4a2d186a9..937d3bdca 100644 --- a/Source/WebKit/qt/Api/qwebview.cpp +++ b/Source/WebKit/qt/Api/qwebview.cpp @@ -703,7 +703,11 @@ bool QWebView::event(QEvent *e) #endif } else if (e->type() == QEvent::TouchBegin || e->type() == QEvent::TouchEnd - || e->type() == QEvent::TouchUpdate) { + || e->type() == QEvent::TouchUpdate +#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) + || e->type() == QEvent::TouchCancel +#endif + ) { d->page->event(e); // Always return true so that we'll receive also TouchUpdate and TouchEnd events diff --git a/Source/WebKit/qt/ChangeLog b/Source/WebKit/qt/ChangeLog index 148a27369..175b43df2 100644 --- a/Source/WebKit/qt/ChangeLog +++ b/Source/WebKit/qt/ChangeLog @@ -1,3 +1,376 @@ +2012-02-24 Holger Hans Peter Freyther <holger@moiji-mobile.com> + + [Qt] Build fix. macro "QSKIP" now only takes 1 argument on Qt5 + https://bugs.webkit.org/show_bug.cgi?id=79328 + + Reviewed by Csaba Osztrogonác. + + Introduce an alternative QSKIP that can work with both Qt4 + and Qt5 without adding #ifdef to each usage site. + + * tests/benchmarks/loading/tst_loading.cpp: + (tst_Loading::load): + * tests/benchmarks/painting/tst_painting.cpp: + (tst_Painting::paint): + * tests/qdeclarativewebview/tst_qdeclarativewebview.cpp: + (tst_QDeclarativeWebView::elementAreaAt): + * tests/qwebframe/tst_qwebframe.cpp: + (tst_QWebFrame::setHtmlWithBaseURL): + * tests/qwebpage/tst_qwebpage.cpp: + (tst_QWebPage::geolocationRequestJS): + (tst_QWebPage::loadHtml5Video): + (tst_QWebPage::screenshot): + * tests/qwebview/tst_qwebview.cpp: + (tst_QWebView::reusePage): + +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/TextCheckerClientQt.h: + (WebCore::TextCheckerClientQt::requestCheckingOfString): + +2012-02-23 Simon Hausmann <simon.hausmann@nokia.com> + + [Qt] Add support for touch cancellation + https://bugs.webkit.org/show_bug.cgi?id=79348 + + Reviewed by Kenneth Rohde Christiansen. + + Forward incoming touch cancellation events to the WebCore + event handler. + + * Api/qgraphicswebview.cpp: + (QGraphicsWebView::sceneEvent): + * Api/qwebpage.cpp: + (QWebPage::event): + * Api/qwebview.cpp: + (QWebView::event): + +2012-02-22 Hajime Morrita <morrita@chromium.org> + + NOTIFICATIONS should be implemented as PageSupplement + https://bugs.webkit.org/show_bug.cgi?id=79052 + + Reviewed by Adam Barth. + + * Api/qwebpage.cpp: + (QWebPagePrivate::QWebPagePrivate): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientQt.cpp: + (WebCore::EditorClientQt::shouldApplyStyle): + * WebCoreSupport/EditorClientQt.h: + (EditorClientQt): + +2012-02-22 Mihnea Ovidenie <mihnea@adobe.com> + + [Qt] REGRESSION(r108108): It made 3 fast/repaint tests fail + https://bugs.webkit.org/show_bug.cgi?id=78960 + + Reviewed by Csaba Osztrogonác. + + * Api/qwebsettings.cpp: + (QWebSettingsPrivate::apply): + (QWebSettings::QWebSettings): + * Api/qwebsettings.h: + +2012-02-22 Simon Hausmann <simon.hausmann@nokia.com> + + [Qt] Move QMenu dependant scrollbar context menu handling out of WebCore + https://bugs.webkit.org/show_bug.cgi?id=79233 + + Reviewed by Kenneth Rohde Christiansen. + + Move scrollbar context menu handling here, it's the only place where it is + used. + + * Api/qwebpage.cpp: + (handleScrollbarContextMenuEvent): + (QWebPage::swallowContextMenuEvent): + +2012-02-22 Kenneth Rohde Christiansen <kenneth@webkit.org> + + Merge setVisibleRectTrajectoryVector and adjustVisibleRect to + the more descriptive coverWithTilesIfNeeded + https://bugs.webkit.org/show_bug.cgi?id=79230 + + Reviewed by Simon Hausmann. + + * Api/qgraphicswebview.cpp: + (QGraphicsWebView::paint): + + Use coverWithTilesIfNeeded(). + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientQt.cpp: + (WebCore::EditorClientQt::shouldApplyStyle): + * WebCoreSupport/EditorClientQt.h: + (EditorClientQt): + +2012-02-21 Csaba Osztrogonác <ossy@webkit.org> + + [Qt] tst_QWebPage::infiniteLoopJS() timeouts with DFG JIT + https://bugs.webkit.org/show_bug.cgi?id=79040 + + Reviewed by Simon Hausmann. + + * tests/qwebpage/tst_qwebpage.cpp: + (tst_QWebPage): Disable tst_QWebPage::infiniteLoopJS() until proper fix. + +2012-02-21 Andras Becsi <andras.becsi@nokia.com> + + [Qt] Print warning when importing experimental WK2 APIs in QML + https://bugs.webkit.org/show_bug.cgi?id=78817 + + Reviewed by Simon Hausmann. + + * declarative/experimental/plugin.cpp: + +2012-02-20 Benjamin Poulain <benjamin@webkit.org> + + Get rid of the LocalizationStrategy + https://bugs.webkit.org/show_bug.cgi?id=78324 + + Reviewed by Sam Weinig. + + Move the localization code from PlatformStrategiesQt.cpp + to LocalizedStringsQt.cpp. + + Get rid of LocalizationStrategy from PlatformStrategiesQt + + * WebCoreSupport/PlatformStrategiesQt.cpp: + * WebCoreSupport/PlatformStrategiesQt.h: + (PlatformStrategiesQt): + +2012-02-16 Simon Hausmann <simon.hausmann@nokia.com> + + Unreviewed brown-paper bag build fix. + + * WebCoreSupport/WebEventConversion.cpp: + (WebCore::WebKitPlatformWheelEvent::WebKitPlatformWheelEvent): + +2012-02-16 Simon Hausmann <simon.hausmann@nokia.com> + + [Qt] Move event conversion functions from WebCore to WebKit + https://bugs.webkit.org/show_bug.cgi?id=78788 + + Reviewed by Kenneth Rohde Christiansen. + + Move QtWidgets dependent mouse event constructors out of WebCore + into WebKit, similar to the web event conversions of WebKit2. + + * Api/qwebpage.cpp: + (QWebPagePrivate::mouseMoveEvent): + (QWebPagePrivate::mousePressEvent): + (QWebPagePrivate::mouseDoubleClickEvent): + (QWebPagePrivate::mouseTripleClickEvent): + (QWebPagePrivate::mouseReleaseEvent): + (QWebPagePrivate::wheelEvent): + (QWebPage::swallowContextMenuEvent): + * WebCoreSupport/FrameLoaderClientQt.cpp: + (WebCore::FrameLoaderClientQt::postProgressFinishedNotification): + * WebCoreSupport/WebEventConversion.cpp: Added. + (WebCore): + (WebCore::mouseEventModifiersFromQtKeyboardModifiers): + (WebCore::mouseEventTypeAndMouseButtonFromQEvent): + (WebKitPlatformMouseEvent): + (WebCore::WebKitPlatformMouseEvent::WebKitPlatformMouseEvent): + (WebCore::convertMouseEvent): + (WebKitPlatformWheelEvent): + (WebCore::WebKitPlatformWheelEvent::applyDelta): + (WebCore::WebKitPlatformWheelEvent::WebKitPlatformWheelEvent): + (WebCore::convertWheelEvent): + * WebCoreSupport/WebEventConversion.h: Added. + (WebCore): + +2012-02-16 Adenilson Cavalcanti <cavalcantii@gmail.com> + + [Qt][WK2] Split QWebPermissionRequest into QWebSecurityOrigin + https://bugs.webkit.org/show_bug.cgi?id=73215 + + Reviewed by Kenneth Rohde Christiansen. + + Adding a class to access security information data + (e.g. port/scheme/etc), + while allowing it to be handled in QML side. + + * declarative/plugin.cpp: + (WebKitQmlPlugin::registerTypes): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebCoreSupport/ChromeClientQt.h: + (WebCore::ChromeClientQt::numTouchEventHandlersChanged): + +2012-02-15 Simon Hausmann <simon.hausmann@nokia.com> + + Unreviewed Qt 4.x build fix. + + * WebCoreSupport/PageClientQt.cpp: Fix the QT_VERSION_CHECK pre-processor foo. + +2012-02-15 Simon Hausmann <simon.hausmann@nokia.com> + + [Qt] Replace use of QGLWidget/QGLContext with QOpenGLContext and QSurface for Qt 5 + https://bugs.webkit.org/show_bug.cgi?id=78694 + + Reviewed by Noam Rosenthal. + + * WebCoreSupport/PageClientQt.cpp: + (createPlatformGraphicsContext3DFromWidget): Return the QOpenGLContext and QSurface + from the QGLWidget when compiling with Qt 5, as that's what WebCore expects. + +2012-02-15 Simon Hausmann <simon.hausmann@nokia.com> + + [Qt] Move Qt platform specific GL Context/Surface creation out of WebCore into WebKit + https://bugs.webkit.org/show_bug.cgi?id=78692 + + Reviewed by Noam Rosenthal. + + Implement GLWidget and GLContext creation from the page client interface. + + * WebCoreSupport/PageClientQt.cpp: + (createPlatformGraphicsContext3DFromWidget): + (WebCore): + (WebCore::PageClientQWidget::createPlatformGraphicsContext3D): + (WebCore::PageClientQGraphicsWidget::createPlatformGraphicsContext3D): + * WebCoreSupport/PageClientQt.h: + (PageClientQWidget): + (PageClientQGraphicsWidget): + +2012-02-14 Simon Hausmann <simon.hausmann@nokia.com> + + [Qt] Eliminate first set of QtWidgets dependencies from WebCore + https://bugs.webkit.org/show_bug.cgi?id=78611 + + Reviewed by Kenneth Rohde Christiansen. + + * Api/qwebpage.cpp: Add missing includes. + * WebCoreSupport/DumpRenderTreeSupportQt.cpp: Ditto. + * WebCoreSupport/FrameLoaderClientQt.cpp: Make it compile by casting + the QObject based PlatformWidget back to QWidget before doing QWidget + specific function calls. + * WebCoreSupport/InitWebCoreQt.cpp: + (WebCore::initializeWebCoreQt): Moved QStyle specific web-graphic initialization + here from WebCore. + * WebCoreSupport/PageClientQt.cpp: + (WebCore::PageClientQWidget::setWidgetVisible): Implement show/hiding of widgets + through delegation to QWidget. + (WebCore): + (WebCore::PageClientQGraphicsWidget::setWidgetVisible): Provide empty widget + show/hide implementation, as it doesn't seem to make sense for graphicsviews. + * WebCoreSupport/PageClientQt.h: + (PageClientQWidget): + (PageClientQGraphicsWidget): + +2012-02-15 Kenneth Rohde Christiansen <kenneth@webkit.org> + + [Qt] Be smarted with tile usages during tiling + https://bugs.webkit.org/show_bug.cgi?id=78243 + + Reviewed by Simon Hausmann. + + Remove internal API used by Symbian. + + * Api/qwebpage.cpp: + (QWebPagePrivate::dynamicPropertyChangeEvent): + +2012-02-15 No'am Rosenthal <noam.rosenthal@nokia.com> + + [Texmap] Divide TextureMapperNode.cpp to 3 files. + https://bugs.webkit.org/show_bug.cgi?id=76660 + + Rename TextureMapperNode to TextureMapperLayer. + + Reviewed by Kenneth Rohde Christiansen. + + * Api/qwebframe.cpp: + (QWebFramePrivate::renderCompositedLayers): + * Api/qwebframe.h: + (WebCore): + * Api/qwebframe_p.h: + (WebCore): + (QWebFramePrivate::QWebFramePrivate): + (QWebFramePrivate): + * WebCoreSupport/PageClientQt.cpp: + (WebCore::TextureMapperLayerClientQt::TextureMapperLayerClientQt): + (WebCore::TextureMapperLayerClientQt::setTextureMapper): + (WebCore::TextureMapperLayerClientQt::~TextureMapperLayerClientQt): + (WebCore::TextureMapperLayerClientQt::syncRootLayer): + (WebCore::TextureMapperLayerClientQt::rootLayer): + (WebCore::PageClientQWidget::setRootGraphicsLayer): + (WebCore::PageClientQWidget::syncLayers): + (WebCore::PageClientQGraphicsWidget::syncLayers): + (WebCore::PageClientQGraphicsWidget::setRootGraphicsLayer): + * WebCoreSupport/PageClientQt.h: + (TextureMapperLayerClientQt): + (PageClientQWidget): + (PageClientQGraphicsWidget): + +2012-02-11 Nikolas Zimmermann <nzimmermann@rim.com> + + Convert svg/animations to use SMIL methods for driving the timeline + https://bugs.webkit.org/show_bug.cgi?id=78422 + + Reviewed by Dirk Schulze. + + Remove SVG animation sampling functionality provided for DRT, which no longer uses it. + Instead we switched the svg/animations tests to use SVGSVGElement.setCurrentTime. + + * WebCoreSupport/DumpRenderTreeSupportQt.cpp: + * WebCoreSupport/DumpRenderTreeSupportQt.h: + +2012-02-13 Enrica Casucci <enrica@apple.com> + + Build fix. Unreviewed. + + * WebCoreSupport/PlatformStrategiesQt.cpp: + (PlatformStrategiesQt::createPasteboardStrategy): + +2012-02-13 Enrica Casucci <enrica@apple.com> + + Refactor Mac platform implementation of the Pasteboard class to use Platform Strategies. + https://bugs.webkit.org/show_bug.cgi?id=78282 + + Build fix. Unreviewed. + + * WebCoreSupport/PlatformStrategiesQt.cpp: + (WebPlatformStrategies::createPasteboardStrategy): + * WebCoreSupport/PlatformStrategiesQt.h: + (PlatformStrategiesQt): + +2012-02-12 Hajime Morrita <morrita@chromium.org> + + Page should have less intrusive way to associate API implementation objects. + https://bugs.webkit.org/show_bug.cgi?id=78085 + + Reviewed by Adam Barth. + + * Api/qwebpage.cpp: + (QWebPagePrivate::QWebPagePrivate): + * WebCoreSupport/DumpRenderTreeSupportQt.cpp: + (DumpRenderTreeSupportQt::setMockDeviceOrientation): + 2012-02-09 Simon Hausmann <simon.hausmann@nokia.com> [Qt] Fix compilation with newer Qt5 diff --git a/Source/WebKit/qt/WebCoreSupport/ChromeClientQt.h b/Source/WebKit/qt/WebCoreSupport/ChromeClientQt.h index 6a576d96d..3d45b7b51 100644 --- a/Source/WebKit/qt/WebCoreSupport/ChromeClientQt.h +++ b/Source/WebKit/qt/WebCoreSupport/ChromeClientQt.h @@ -192,6 +192,7 @@ public: virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const { return true; } virtual void numWheelEventHandlersChanged(unsigned) { } + virtual void numTouchEventHandlersChanged(unsigned) { } QWebPage* m_webPage; KURL lastHoverURL; diff --git a/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp b/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp index 90254aeca..92c98cd37 100644 --- a/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp +++ b/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp @@ -78,10 +78,6 @@ #include "SecurityOrigin.h" #include "SecurityPolicy.h" #include "Settings.h" -#if ENABLE(SVG) -#include "SVGDocumentExtensions.h" -#include "SVGSMILElement.h" -#endif #include "TextIterator.h" #include "ThirdPartyCookiesQt.h" #include "WebCoreTestSupport.h" @@ -102,6 +98,9 @@ #include "MediaPlayerPrivateQt.h" #endif +#include <QAction> +#include <QMenu> + using namespace WebCore; QMap<int, QWebScriptWorld*> m_worldMap; @@ -370,31 +369,6 @@ bool DumpRenderTreeSupportQt::pauseTransitionOfProperty(QWebFrame *frame, const return controller->pauseTransitionAtTime(coreNode->renderer(), propertyName, time); } -// Pause a given SVG animation on the target node at a specific time. -// This method is only intended to be used for testing the SVG animation system. -bool DumpRenderTreeSupportQt::pauseSVGAnimation(QWebFrame *frame, const QString &animationId, double time, const QString &elementId) -{ -#if !ENABLE(SVG) - return false; -#else - Frame* coreFrame = QWebFramePrivate::core(frame); - if (!coreFrame) - return false; - - Document* doc = coreFrame->document(); - Q_ASSERT(doc); - - if (!doc->svgExtensions()) - return false; - - Node* coreNode = doc->getElementById(animationId); - if (!coreNode || !SVGSMILElement::isSMILElement(coreNode)) - return false; - - return doc->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time); -#endif -} - // Returns the total number of currently running animations (includes both CSS transitions and CSS animations). int DumpRenderTreeSupportQt::numberOfActiveAnimations(QWebFrame *frame) { @@ -635,7 +609,7 @@ QVariantMap DumpRenderTreeSupportQt::computedStyleIncludingVisitedInfo(const QWe if (!webElement) return res; - RefPtr<WebCore::CSSComputedStyleDeclaration> computedStyleDeclaration = computedStyle(webElement, true); + RefPtr<WebCore::CSSComputedStyleDeclaration> computedStyleDeclaration = CSSComputedStyleDeclaration::create(webElement, true); CSSStyleDeclaration* style = static_cast<WebCore::CSSStyleDeclaration*>(computedStyleDeclaration.get()); for (unsigned i = 0; i < style->length(); i++) { QString name = style->item(i); @@ -857,7 +831,7 @@ void DumpRenderTreeSupportQt::setMockDeviceOrientation(QWebPage* page, bool canP { #if ENABLE(DEVICE_ORIENTATION) Page* corePage = QWebPagePrivate::core(page); - DeviceOrientationClientMock* mockClient = toDeviceOrientationClientMock(corePage->deviceOrientationController()->client()); + DeviceOrientationClientMock* mockClient = toDeviceOrientationClientMock(DeviceOrientationController::from(corePage)->client()); mockClient->setOrientation(DeviceOrientation::create(canProvideAlpha, alpha, canProvideBeta, beta, canProvideGamma, gamma)); #endif } diff --git a/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h b/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h index 7aa9f1dce..4b0314350 100644 --- a/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h +++ b/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h @@ -112,7 +112,6 @@ public: static bool pauseAnimation(QWebFrame*, const QString& name, double time, const QString& elementId); static bool pauseTransitionOfProperty(QWebFrame*, const QString& name, double time, const QString& elementId); - static bool pauseSVGAnimation(QWebFrame*, const QString& animationId, double time, const QString& elementId); static void suspendActiveDOMObjects(QWebFrame* frame); static void resumeActiveDOMObjects(QWebFrame* frame); diff --git a/Source/WebKit/qt/WebCoreSupport/EditorClientQt.cpp b/Source/WebKit/qt/WebCoreSupport/EditorClientQt.cpp index 1d808031f..166e0063f 100644 --- a/Source/WebKit/qt/WebCoreSupport/EditorClientQt.cpp +++ b/Source/WebKit/qt/WebCoreSupport/EditorClientQt.cpp @@ -31,7 +31,6 @@ #include "config.h" #include "EditorClientQt.h" -#include "CSSStyleDeclaration.h" #include "Document.h" #include "UndoStepQt.h" #include "Editor.h" @@ -48,6 +47,7 @@ #include "Range.h" #include "Settings.h" #include "SpatialNavigation.h" +#include "StylePropertySet.h" #include "WindowsKeyboardCodes.h" #include "qwebpage.h" #include "qwebpage_p.h" @@ -170,12 +170,12 @@ bool EditorClientQt::shouldChangeSelectedRange(Range* currentRange, Range* propo return acceptsEditing; } -bool EditorClientQt::shouldApplyStyle(WebCore::CSSStyleDeclaration* style, +bool EditorClientQt::shouldApplyStyle(WebCore::StylePropertySet* style, WebCore::Range* range) { if (dumpEditingCallbacks) printf("EDITING DELEGATE: shouldApplyStyle:%s toElementsInDOMRange:%s\n", - QString(style->cssText()).toUtf8().constData(), dumpRange(range).toUtf8().constData()); + QString(style->asText()).toUtf8().constData(), dumpRange(range).toUtf8().constData()); return acceptsEditing; } diff --git a/Source/WebKit/qt/WebCoreSupport/EditorClientQt.h b/Source/WebKit/qt/WebCoreSupport/EditorClientQt.h index c20f97576..2830989e4 100644 --- a/Source/WebKit/qt/WebCoreSupport/EditorClientQt.h +++ b/Source/WebKit/qt/WebCoreSupport/EditorClientQt.h @@ -63,7 +63,7 @@ public: virtual bool shouldInsertText(const String&, Range*, EditorInsertAction); virtual bool shouldChangeSelectedRange(Range* fromRange, Range* toRange, EAffinity, bool stillSelecting); - virtual bool shouldApplyStyle(CSSStyleDeclaration*, Range*); + virtual bool shouldApplyStyle(StylePropertySet*, Range*); virtual bool shouldMoveRangeAfterDelete(Range*, Range*); diff --git a/Source/WebKit/qt/WebCoreSupport/FrameLoaderClientQt.cpp b/Source/WebKit/qt/WebCoreSupport/FrameLoaderClientQt.cpp index b3588361e..8364219d6 100644 --- a/Source/WebKit/qt/WebCoreSupport/FrameLoaderClientQt.cpp +++ b/Source/WebKit/qt/WebCoreSupport/FrameLoaderClientQt.cpp @@ -73,6 +73,7 @@ #include "V8DOMWindow.h" #endif #include "ViewportArguments.h" +#include "WebEventConversion.h" #include "qwebframe.h" #include "qwebframe_p.h" @@ -606,7 +607,7 @@ void FrameLoaderClientQt::postProgressFinishedNotification() QPoint localPos = view->mapFromGlobal(QCursor::pos()); if (view->rect().contains(localPos)) { QMouseEvent event(QEvent::MouseMove, localPos, Qt::NoButton, Qt::NoButton, Qt::NoModifier); - m_frame->eventHandler()->mouseMoved(PlatformMouseEvent(&event, 0)); + m_frame->eventHandler()->mouseMoved(convertMouseEvent(&event, 0)); } } } @@ -1451,15 +1452,16 @@ public: virtual void invalidateRect(const IntRect& r) { if (platformWidget()) - platformWidget()->update(r); + static_cast<QWidget*>(platformWidget())->update(r); } virtual void frameRectsChanged() { - if (!platformWidget()) + QWidget* widget = static_cast<QWidget*>(platformWidget()); + if (!widget) return; IntRect windowRect = convertToContainingWindow(IntRect(0, 0, frameRect().width(), frameRect().height())); - platformWidget()->setGeometry(windowRect); + widget->setGeometry(windowRect); ScrollView* parentScrollView = parent(); if (!parentScrollView) @@ -1468,14 +1470,14 @@ public: ASSERT(parentScrollView->isFrameView()); IntRect clipRect(static_cast<FrameView*>(parentScrollView)->windowClipRect()); clipRect.move(-windowRect.x(), -windowRect.y()); - clipRect.intersect(platformWidget()->rect()); + clipRect.intersect(widget->rect()); QRegion clipRegion = QRegion(clipRect); - platformWidget()->setMask(clipRegion); + widget->setMask(clipRegion); handleVisibility(); - platformWidget()->update(); + widget->update(); } virtual void show() @@ -1490,10 +1492,11 @@ private: if (!isVisible()) return; + QWidget* widget = static_cast<QWidget*>(platformWidget()); // If setMask is set with an empty QRegion, no clipping will // be performed, so in that case we hide the platformWidget. - QRegion mask = platformWidget()->mask(); - platformWidget()->setVisible(!mask.isEmpty()); + QRegion mask = widget->mask(); + widget->setVisible(!mask.isEmpty()); } }; @@ -1590,7 +1593,7 @@ PassRefPtr<Widget> FrameLoaderClientQt::createPlugin(const IntSize& pluginSize, styleSheet += QString::fromLatin1(getPropertyName(property)); styleSheet += QLatin1Char(':'); - styleSheet += computedStyle(element)->getPropertyValue(property); + styleSheet += CSSComputedStyleDeclaration::create(element)->getPropertyValue(property); styleSheet += QLatin1Char(';'); } diff --git a/Source/WebKit/qt/WebCoreSupport/InitWebCoreQt.cpp b/Source/WebKit/qt/WebCoreSupport/InitWebCoreQt.cpp index 40f6fe7c9..5cbd82c58 100644 --- a/Source/WebKit/qt/WebCoreSupport/InitWebCoreQt.cpp +++ b/Source/WebKit/qt/WebCoreSupport/InitWebCoreQt.cpp @@ -30,6 +30,7 @@ #include "config.h" #include "InitWebCoreQt.h" +#include "Image.h" #include "NotImplemented.h" #include "PlatformStrategiesQt.h" #include "ScriptController.h" @@ -39,6 +40,8 @@ #endif #include "qwebelement_p.h" +#include <QApplication> +#include <QStyle> #include <runtime/InitializeThreading.h> #include <wtf/MainThread.h> @@ -63,6 +66,11 @@ void initializeWebCoreQt() InitWebCoreSystemInterface(); #endif + // QWebSettings::SearchCancelButtonGraphic + Image::setPlatformResource("searchCancelButton", QApplication::style()->standardPixmap(QStyle::SP_DialogCloseButton)); + // QWebSettings::SearchCancelButtonPressedGraphic + Image::setPlatformResource("searchCancelButtonPressed", QApplication::style()->standardPixmap(QStyle::SP_DialogCloseButton)); + initialized = true; } diff --git a/Source/WebKit/qt/WebCoreSupport/PageClientQt.cpp b/Source/WebKit/qt/WebCoreSupport/PageClientQt.cpp index 45dcfbbe1..6f96ce1ba 100644 --- a/Source/WebKit/qt/WebCoreSupport/PageClientQt.cpp +++ b/Source/WebKit/qt/WebCoreSupport/PageClientQt.cpp @@ -27,56 +27,93 @@ #include <QX11Info> #endif +#if ENABLE(WEBGL) +#include <QGLWidget> + +#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) +#include <QWindow> +#endif + +static void createPlatformGraphicsContext3DFromWidget(QWidget* widget, PlatformGraphicsContext3D* context, + PlatformGraphicsSurface3D* surface) +{ + *context = 0; + *surface = 0; + QAbstractScrollArea* scrollArea = qobject_cast<QAbstractScrollArea*>(widget); + if (!scrollArea) + return; + + QGLWidget* glViewport = qobject_cast<QGLWidget*>(scrollArea->viewport()); + if (!glViewport) + return; + QGLWidget* glWidget = new QGLWidget(0, glViewport); + if (glWidget->isValid()) { + // Geometry can be set to zero because m_glWidget is used only for its QGLContext. + glWidget->setGeometry(0, 0, 0, 0); +#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) + *surface = glWidget->windowHandle(); + *context = glWidget->context()->contextHandle(); +#else + *surface = glWidget; + *context = const_cast<QGLContext*>(glWidget->context()); +#endif + } else { + delete glWidget; + glWidget = 0; + } +} +#endif + #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) #include "TextureMapper.h" -#include "texmap/TextureMapperNode.h" +#include "texmap/TextureMapperLayer.h" #endif namespace WebCore { #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) -TextureMapperNodeClientQt::TextureMapperNodeClientQt(QWebFrame* frame, GraphicsLayer* layer) +TextureMapperLayerClientQt::TextureMapperLayerClientQt(QWebFrame* frame, GraphicsLayer* layer) : m_frame(frame) , m_rootGraphicsLayer(GraphicsLayer::create(0)) { - m_frame->d->rootTextureMapperNode = rootNode(); + m_frame->d->rootTextureMapperLayer = rootLayer(); m_rootGraphicsLayer->addChild(layer); m_rootGraphicsLayer->setDrawsContent(false); m_rootGraphicsLayer->setMasksToBounds(false); m_rootGraphicsLayer->setSize(IntSize(1, 1)); } -void TextureMapperNodeClientQt::setTextureMapper(const PassOwnPtr<TextureMapper>& textureMapper) +void TextureMapperLayerClientQt::setTextureMapper(const PassOwnPtr<TextureMapper>& textureMapper) { m_frame->d->textureMapper = textureMapper; - m_frame->d->rootTextureMapperNode->setTextureMapper(m_frame->d->textureMapper.get()); + m_frame->d->rootTextureMapperLayer->setTextureMapper(m_frame->d->textureMapper.get()); } -TextureMapperNodeClientQt::~TextureMapperNodeClientQt() +TextureMapperLayerClientQt::~TextureMapperLayerClientQt() { - m_frame->d->rootTextureMapperNode = 0; + m_frame->d->rootTextureMapperLayer = 0; } -void TextureMapperNodeClientQt::syncRootLayer() +void TextureMapperLayerClientQt::syncRootLayer() { m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly(); } -TextureMapperNode* TextureMapperNodeClientQt::rootNode() +TextureMapperLayer* TextureMapperLayerClientQt::rootLayer() { - return toTextureMapperNode(m_rootGraphicsLayer.get()); + return toTextureMapperLayer(m_rootGraphicsLayer.get()); } void PageClientQWidget::setRootGraphicsLayer(GraphicsLayer* layer) { if (layer) { - textureMapperNodeClient = adoptPtr(new TextureMapperNodeClientQt(page->mainFrame(), layer)); - textureMapperNodeClient->setTextureMapper(TextureMapper::create()); - textureMapperNodeClient->syncRootLayer(); + TextureMapperLayerClient = adoptPtr(new TextureMapperLayerClientQt(page->mainFrame(), layer)); + TextureMapperLayerClient->setTextureMapper(TextureMapper::create()); + TextureMapperLayerClient->syncRootLayer(); return; } - textureMapperNodeClient.clear(); + TextureMapperLayerClient.clear(); } void PageClientQWidget::markForSync(bool scheduleSync) @@ -88,12 +125,12 @@ void PageClientQWidget::markForSync(bool scheduleSync) void PageClientQWidget::syncLayers(Timer<PageClientQWidget>*) { - if (textureMapperNodeClient) - textureMapperNodeClient->syncRootLayer(); + if (TextureMapperLayerClient) + TextureMapperLayerClient->syncRootLayer(); QWebFramePrivate::core(page->mainFrame())->view()->syncCompositingStateIncludingSubframes(); - if (!textureMapperNodeClient) + if (!TextureMapperLayerClient) return; - if (textureMapperNodeClient->rootNode()->descendantsOrSelfHaveRunningAnimations() && !syncTimer.isActive()) + if (TextureMapperLayerClient->rootLayer()->descendantsOrSelfHaveRunningAnimations() && !syncTimer.isActive()) syncTimer.startOneShot(1.0 / 60.0); update(view->rect()); } @@ -178,6 +215,22 @@ QRectF PageClientQWidget::windowRect() const return QRectF(view->window()->geometry()); } +void PageClientQWidget::setWidgetVisible(Widget* widget, bool visible) +{ + QWidget* qtWidget = qobject_cast<QWidget*>(widget->platformWidget()); + if (!qtWidget) + return; + qtWidget->setVisible(visible); +} + +#if ENABLE(WEBGL) +void PageClientQWidget::createPlatformGraphicsContext3D(PlatformGraphicsContext3D* context, + PlatformGraphicsSurface3D* surface) +{ + createPlatformGraphicsContext3DFromWidget(view, context, surface); +} +#endif + #if !defined(QT_NO_GRAPHICSVIEW) PageClientQGraphicsWidget::~PageClientQGraphicsWidget() { @@ -239,17 +292,17 @@ void PageClientQGraphicsWidget::createOrDeleteOverlay() void PageClientQGraphicsWidget::syncLayers() { #if USE(TEXTURE_MAPPER) - if (textureMapperNodeClient) - textureMapperNodeClient->syncRootLayer(); + if (TextureMapperLayerClient) + TextureMapperLayerClient->syncRootLayer(); #endif QWebFramePrivate::core(page->mainFrame())->view()->syncCompositingStateIncludingSubframes(); #if USE(TEXTURE_MAPPER) - if (!textureMapperNodeClient) + if (!TextureMapperLayerClient) return; - if (textureMapperNodeClient->rootNode()->descendantsOrSelfHaveRunningAnimations() && !syncTimer.isActive()) + if (TextureMapperLayerClient->rootLayer()->descendantsOrSelfHaveRunningAnimations() && !syncTimer.isActive()) syncTimer.startOneShot(1.0 / 60.0); update(view->boundingRect().toAlignedRect()); #endif @@ -259,18 +312,18 @@ void PageClientQGraphicsWidget::syncLayers() void PageClientQGraphicsWidget::setRootGraphicsLayer(GraphicsLayer* layer) { if (layer) { - textureMapperNodeClient = adoptPtr(new TextureMapperNodeClientQt(page->mainFrame(), layer)); + TextureMapperLayerClient = adoptPtr(new TextureMapperLayerClientQt(page->mainFrame(), layer)); #if USE(TEXTURE_MAPPER_GL) QGraphicsView* graphicsView = view->scene()->views()[0]; if (graphicsView && graphicsView->viewport() && graphicsView->viewport()->inherits("QGLWidget")) { - textureMapperNodeClient->setTextureMapper(TextureMapper::create(TextureMapper::OpenGLMode)); + TextureMapperLayerClient->setTextureMapper(TextureMapper::create(TextureMapper::OpenGLMode)); return; } #endif - textureMapperNodeClient->setTextureMapper(TextureMapper::create()); + TextureMapperLayerClient->setTextureMapper(TextureMapper::create()); return; } - textureMapperNodeClient.clear(); + TextureMapperLayerClient.clear(); } #else void PageClientQGraphicsWidget::setRootGraphicsLayer(GraphicsLayer* layer) @@ -405,6 +458,11 @@ QStyle* PageClientQGraphicsWidget::style() const return view->style(); } +void PageClientQGraphicsWidget::setWidgetVisible(Widget*, bool) +{ + // Doesn't make sense, does it? +} + QRectF PageClientQGraphicsWidget::windowRect() const { if (!view->scene()) @@ -415,4 +473,12 @@ QRectF PageClientQGraphicsWidget::windowRect() const } #endif // QT_NO_GRAPHICSVIEW +#if ENABLE(WEBGL) +void PageClientQGraphicsWidget::createPlatformGraphicsContext3D(PlatformGraphicsContext3D* context, + PlatformGraphicsSurface3D* surface) +{ + createPlatformGraphicsContext3DFromWidget(ownerWidget(), context, surface); +} +#endif + } // namespace WebCore diff --git a/Source/WebKit/qt/WebCoreSupport/PageClientQt.h b/Source/WebKit/qt/WebCoreSupport/PageClientQt.h index 3480449d2..9a2636572 100644 --- a/Source/WebKit/qt/WebCoreSupport/PageClientQt.h +++ b/Source/WebKit/qt/WebCoreSupport/PageClientQt.h @@ -44,13 +44,13 @@ namespace WebCore { #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) -class TextureMapperNodeClientQt { +class TextureMapperLayerClientQt { public: - TextureMapperNodeClientQt(QWebFrame*, GraphicsLayer*); - virtual ~TextureMapperNodeClientQt(); + TextureMapperLayerClientQt(QWebFrame*, GraphicsLayer*); + virtual ~TextureMapperLayerClientQt(); void setTextureMapper(const PassOwnPtr<TextureMapper>&); void syncRootLayer(); - TextureMapperNode* rootNode(); + TextureMapperLayer* rootLayer(); private: QWebFrame* m_frame; @@ -97,6 +97,13 @@ public: virtual QRectF windowRect() const; + virtual void setWidgetVisible(Widget*, bool visible); + +#if ENABLE(WEBGL) + virtual void createPlatformGraphicsContext3D(PlatformGraphicsContext3D*, + PlatformGraphicsSurface3D*); +#endif + QWidget* view; QWebPage* page; @@ -114,7 +121,7 @@ public: #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER) Timer<PageClientQWidget> syncTimer; - OwnPtr<TextureMapperNodeClientQt> textureMapperNodeClient; + OwnPtr<TextureMapperLayerClientQt> TextureMapperLayerClient; #endif }; @@ -198,6 +205,13 @@ public: virtual bool viewResizesToContentsEnabled() const { return viewResizesToContents; } + virtual void setWidgetVisible(Widget*, bool); + +#if ENABLE(WEBGL) + virtual void createPlatformGraphicsContext3D(PlatformGraphicsContext3D*, + PlatformGraphicsSurface3D*); +#endif + void createOrDeleteOverlay(); #if USE(TILED_BACKING_STORE) @@ -223,7 +237,7 @@ public: #if USE(ACCELERATED_COMPOSITING) #if USE(TEXTURE_MAPPER) - OwnPtr<TextureMapperNodeClientQt> textureMapperNodeClient; + OwnPtr<TextureMapperLayerClientQt> TextureMapperLayerClient; #else QWeakPointer<QGraphicsObject> rootGraphicsLayer; #endif diff --git a/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.cpp b/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.cpp index 64d424d95..cd4ab0d72 100644 --- a/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.cpp +++ b/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.cpp @@ -68,14 +68,14 @@ PluginStrategy* PlatformStrategiesQt::createPluginStrategy() return this; } -LocalizationStrategy* PlatformStrategiesQt::createLocalizationStrategy() +VisitedLinkStrategy* PlatformStrategiesQt::createVisitedLinkStrategy() { return this; } -VisitedLinkStrategy* PlatformStrategiesQt::createVisitedLinkStrategy() +PasteboardStrategy* PlatformStrategiesQt::createPasteboardStrategy() { - return this; + return 0; } void PlatformStrategiesQt::notifyCookiesChanged() @@ -145,608 +145,6 @@ void PlatformStrategiesQt::getPluginInfo(const WebCore::Page* page, Vector<WebCo } - -// LocalizationStrategy - -String PlatformStrategiesQt::inputElementAltText() -{ - return QCoreApplication::translate("QWebPage", "Submit", "Submit (input element) alt text for <input> elements with no alt, title, or value"); -} - -String PlatformStrategiesQt::resetButtonDefaultLabel() -{ - return QCoreApplication::translate("QWebPage", "Reset", "default label for Reset buttons in forms on web pages"); -} - -String PlatformStrategiesQt::searchableIndexIntroduction() -{ - return QCoreApplication::translate("QWebPage", "This is a searchable index. Enter search keywords: ", "text that appears at the start of nearly-obsolete web pages in the form of a 'searchable index'"); -} - -String PlatformStrategiesQt::submitButtonDefaultLabel() -{ - return QCoreApplication::translate("QWebPage", "Submit", "default label for Submit buttons in forms on web pages"); -} - -String PlatformStrategiesQt::fileButtonChooseFileLabel() -{ - return QCoreApplication::translate("QWebPage", "Choose File", "title for a single file chooser button used in HTML forms"); -} - -String PlatformStrategiesQt::fileButtonChooseMultipleFilesLabel() -{ - return QCoreApplication::translate("QWebPage", "Choose Files", "title for a multiple file chooser button used in HTML forms. This title should be as short as possible."); -} - -String PlatformStrategiesQt::fileButtonNoFileSelectedLabel() -{ - return QCoreApplication::translate("QWebPage", "No file selected", "text to display in file button used in HTML forms when no file is selected"); -} - -String PlatformStrategiesQt::fileButtonNoFilesSelectedLabel() -{ - return QCoreApplication::translate("QWebPage", "No files selected", "text to display in file button used in HTML forms when no files are selected and the button allows multiple files to be selected"); -} - -String PlatformStrategiesQt::defaultDetailsSummaryText() -{ - return QCoreApplication::translate("QWebPage", "Details", "text to display in <details> tag when it has no <summary> child"); -} - -String PlatformStrategiesQt::contextMenuItemTagOpenLinkInNewWindow() -{ - return QCoreApplication::translate("QWebPage", "Open in New Window", "Open in New Window context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagDownloadLinkToDisk() -{ - return QCoreApplication::translate("QWebPage", "Save Link...", "Download Linked File context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCopyLinkToClipboard() -{ - return QCoreApplication::translate("QWebPage", "Copy Link", "Copy Link context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagOpenImageInNewWindow() -{ - return QCoreApplication::translate("QWebPage", "Open Image", "Open Image in New Window context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagDownloadImageToDisk() -{ - return QCoreApplication::translate("QWebPage", "Save Image", "Download Image context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCopyImageToClipboard() -{ - return QCoreApplication::translate("QWebPage", "Copy Image", "Copy Link context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCopyImageUrlToClipboard() -{ - return QCoreApplication::translate("QWebPage", "Copy Image Address", "Copy Image Address menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagOpenVideoInNewWindow() -{ - return QCoreApplication::translate("QWebPage", "Open Video", "Open Video in New Window"); -} - -String PlatformStrategiesQt::contextMenuItemTagOpenAudioInNewWindow() -{ - return QCoreApplication::translate("QWebPage", "Open Audio", "Open Audio in New Window"); -} - -String PlatformStrategiesQt::contextMenuItemTagCopyVideoLinkToClipboard() -{ - return QCoreApplication::translate("QWebPage", "Copy Video", "Copy Video Link Location"); -} - -String PlatformStrategiesQt::contextMenuItemTagCopyAudioLinkToClipboard() -{ - return QCoreApplication::translate("QWebPage", "Copy Audio", "Copy Audio Link Location"); -} - -String PlatformStrategiesQt::contextMenuItemTagToggleMediaControls() -{ - return QCoreApplication::translate("QWebPage", "Toggle Controls", "Toggle Media Controls"); -} - -String PlatformStrategiesQt::contextMenuItemTagToggleMediaLoop() -{ - return QCoreApplication::translate("QWebPage", "Toggle Loop", "Toggle Media Loop Playback"); -} - -String PlatformStrategiesQt::contextMenuItemTagEnterVideoFullscreen() -{ - return QCoreApplication::translate("QWebPage", "Enter Fullscreen", "Switch Video to Fullscreen"); -} - -String PlatformStrategiesQt::contextMenuItemTagMediaPlay() -{ - return QCoreApplication::translate("QWebPage", "Play", "Play"); -} - -String PlatformStrategiesQt::contextMenuItemTagMediaPause() -{ - return QCoreApplication::translate("QWebPage", "Pause", "Pause"); -} - -String PlatformStrategiesQt::contextMenuItemTagMediaMute() -{ - return QCoreApplication::translate("QWebPage", "Mute", "Mute"); -} - -String PlatformStrategiesQt::contextMenuItemTagOpenFrameInNewWindow() -{ - return QCoreApplication::translate("QWebPage", "Open Frame", "Open Frame in New Window context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCopy() -{ - return QCoreApplication::translate("QWebPage", "Copy", "Copy context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagGoBack() -{ - return QCoreApplication::translate("QWebPage", "Go Back", "Back context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagGoForward() -{ - return QCoreApplication::translate("QWebPage", "Go Forward", "Forward context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagStop() -{ - return QCoreApplication::translate("QWebPage", "Stop", "Stop context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagReload() -{ - return QCoreApplication::translate("QWebPage", "Reload", "Reload context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCut() -{ - return QCoreApplication::translate("QWebPage", "Cut", "Cut context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagPaste() -{ - return QCoreApplication::translate("QWebPage", "Paste", "Paste context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagSelectAll() -{ - return QCoreApplication::translate("QWebPage", "Select All", "Select All context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagNoGuessesFound() -{ - return QCoreApplication::translate("QWebPage", "No Guesses Found", "No Guesses Found context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagIgnoreSpelling() -{ - return QCoreApplication::translate("QWebPage", "Ignore", "Ignore Spelling context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagLearnSpelling() -{ - return QCoreApplication::translate("QWebPage", "Add To Dictionary", "Learn Spelling context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagSearchWeb() -{ - return QCoreApplication::translate("QWebPage", "Search The Web", "Search The Web context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagLookUpInDictionary(const String&) -{ - return QCoreApplication::translate("QWebPage", "Look Up In Dictionary", "Look Up in Dictionary context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagOpenLink() -{ - return QCoreApplication::translate("QWebPage", "Open Link", "Open Link context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagIgnoreGrammar() -{ - return QCoreApplication::translate("QWebPage", "Ignore", "Ignore Grammar context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagSpellingMenu() -{ - return QCoreApplication::translate("QWebPage", "Spelling", "Spelling and Grammar context sub-menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagShowSpellingPanel(bool show) -{ - return show ? QCoreApplication::translate("QWebPage", "Show Spelling and Grammar", "menu item title") : - QCoreApplication::translate("QWebPage", "Hide Spelling and Grammar", "menu item title"); -} - -String PlatformStrategiesQt::contextMenuItemTagCheckSpelling() -{ - return QCoreApplication::translate("QWebPage", "Check Spelling", "Check spelling context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCheckSpellingWhileTyping() -{ - return QCoreApplication::translate("QWebPage", "Check Spelling While Typing", "Check spelling while typing context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagCheckGrammarWithSpelling() -{ - return QCoreApplication::translate("QWebPage", "Check Grammar With Spelling", "Check grammar with spelling context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagFontMenu() -{ - return QCoreApplication::translate("QWebPage", "Fonts", "Font context sub-menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagBold() -{ - return QCoreApplication::translate("QWebPage", "Bold", "Bold context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagItalic() -{ - return QCoreApplication::translate("QWebPage", "Italic", "Italic context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagUnderline() -{ - return QCoreApplication::translate("QWebPage", "Underline", "Underline context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagOutline() -{ - return QCoreApplication::translate("QWebPage", "Outline", "Outline context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagWritingDirectionMenu() -{ - return QCoreApplication::translate("QWebPage", "Direction", "Writing direction context sub-menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagTextDirectionMenu() -{ - return QCoreApplication::translate("QWebPage", "Text Direction", "Text direction context sub-menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagDefaultDirection() -{ - return QCoreApplication::translate("QWebPage", "Default", "Default writing direction context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagLeftToRight() -{ - return QCoreApplication::translate("QWebPage", "Left to Right", "Left to Right context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagRightToLeft() -{ - return QCoreApplication::translate("QWebPage", "Right to Left", "Right to Left context menu item"); -} - -String PlatformStrategiesQt::contextMenuItemTagInspectElement() -{ - return QCoreApplication::translate("QWebPage", "Inspect", "Inspect Element context menu item"); -} - -String PlatformStrategiesQt::searchMenuNoRecentSearchesText() -{ - return QCoreApplication::translate("QWebPage", "No recent searches", "Label for only item in menu that appears when clicking on the search field image, when no searches have been performed"); -} - -String PlatformStrategiesQt::searchMenuRecentSearchesText() -{ - return QCoreApplication::translate("QWebPage", "Recent searches", "label for first item in the menu that appears when clicking on the search field image, used as embedded menu title"); -} - -String PlatformStrategiesQt::searchMenuClearRecentSearchesText() -{ - return QCoreApplication::translate("QWebPage", "Clear recent searches", "menu item in Recent Searches menu that empties menu's contents"); -} - -String PlatformStrategiesQt::AXWebAreaText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXLinkText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXListMarkerText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXImageMapText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXHeadingText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXDefinitionListTermText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXDefinitionListDefinitionText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXButtonActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXRadioButtonActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXTextFieldActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXCheckedCheckBoxActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXUncheckedCheckBoxActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXMenuListActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXMenuListPopupActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::AXLinkActionVerb() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::missingPluginText() -{ - return QCoreApplication::translate("QWebPage", "Missing Plug-in", "Label text to be used when a plug-in is missing"); -} - -String PlatformStrategiesQt::crashedPluginText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::multipleFileUploadText(unsigned) -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::unknownFileSizeText() -{ - return QCoreApplication::translate("QWebPage", "Unknown", "Unknown filesize FTP directory listing item"); -} - -String PlatformStrategiesQt::imageTitle(const String& filename, const IntSize& size) -{ - return QCoreApplication::translate("QWebPage", "%1 (%2x%3 pixels)", "Title string for images").arg(filename).arg(size.width()).arg(size.height()); -} - -String PlatformStrategiesQt::mediaElementLoadingStateText() -{ - return QCoreApplication::translate("QWebPage", "Loading...", "Media controller status message when the media is loading"); -} - -String PlatformStrategiesQt::mediaElementLiveBroadcastStateText() -{ - return QCoreApplication::translate("QWebPage", "Live Broadcast", "Media controller status message when watching a live broadcast"); -} - -#if ENABLE(VIDEO) - -String PlatformStrategiesQt::localizedMediaControlElementString(const String& name) -{ - if (name == "AudioElement") - return QCoreApplication::translate("QWebPage", "Audio Element", "Media controller element"); - if (name == "VideoElement") - return QCoreApplication::translate("QWebPage", "Video Element", "Media controller element"); - if (name == "MuteButton") - return QCoreApplication::translate("QWebPage", "Mute Button", "Media controller element"); - if (name == "UnMuteButton") - return QCoreApplication::translate("QWebPage", "Unmute Button", "Media controller element"); - if (name == "PlayButton") - return QCoreApplication::translate("QWebPage", "Play Button", "Media controller element"); - if (name == "PauseButton") - return QCoreApplication::translate("QWebPage", "Pause Button", "Media controller element"); - if (name == "Slider") - return QCoreApplication::translate("QWebPage", "Slider", "Media controller element"); - if (name == "SliderThumb") - return QCoreApplication::translate("QWebPage", "Slider Thumb", "Media controller element"); - if (name == "RewindButton") - return QCoreApplication::translate("QWebPage", "Rewind Button", "Media controller element"); - if (name == "ReturnToRealtimeButton") - return QCoreApplication::translate("QWebPage", "Return to Real-time Button", "Media controller element"); - if (name == "CurrentTimeDisplay") - return QCoreApplication::translate("QWebPage", "Elapsed Time", "Media controller element"); - if (name == "TimeRemainingDisplay") - return QCoreApplication::translate("QWebPage", "Remaining Time", "Media controller element"); - if (name == "StatusDisplay") - return QCoreApplication::translate("QWebPage", "Status Display", "Media controller element"); - if (name == "FullscreenButton") - return QCoreApplication::translate("QWebPage", "Fullscreen Button", "Media controller element"); - if (name == "SeekForwardButton") - return QCoreApplication::translate("QWebPage", "Seek Forward Button", "Media controller element"); - if (name == "SeekBackButton") - return QCoreApplication::translate("QWebPage", "Seek Back Button", "Media controller element"); - - return String(); -} - -String PlatformStrategiesQt::localizedMediaControlElementHelpText(const String& name) -{ - if (name == "AudioElement") - return QCoreApplication::translate("QWebPage", "Audio element playback controls and status display", "Media controller element"); - if (name == "VideoElement") - return QCoreApplication::translate("QWebPage", "Video element playback controls and status display", "Media controller element"); - if (name == "MuteButton") - return QCoreApplication::translate("QWebPage", "Mute audio tracks", "Media controller element"); - if (name == "UnMuteButton") - return QCoreApplication::translate("QWebPage", "Unmute audio tracks", "Media controller element"); - if (name == "PlayButton") - return QCoreApplication::translate("QWebPage", "Begin playback", "Media controller element"); - if (name == "PauseButton") - return QCoreApplication::translate("QWebPage", "Pause playback", "Media controller element"); - if (name == "Slider") - return QCoreApplication::translate("QWebPage", "Movie time scrubber", "Media controller element"); - if (name == "SliderThumb") - return QCoreApplication::translate("QWebPage", "Movie time scrubber thumb", "Media controller element"); - if (name == "RewindButton") - return QCoreApplication::translate("QWebPage", "Rewind movie", "Media controller element"); - if (name == "ReturnToRealtimeButton") - return QCoreApplication::translate("QWebPage", "Return streaming movie to real-time", "Media controller element"); - if (name == "CurrentTimeDisplay") - return QCoreApplication::translate("QWebPage", "Current movie time", "Media controller element"); - if (name == "TimeRemainingDisplay") - return QCoreApplication::translate("QWebPage", "Remaining movie time", "Media controller element"); - if (name == "StatusDisplay") - return QCoreApplication::translate("QWebPage", "Current movie status", "Media controller element"); - if (name == "FullscreenButton") - return QCoreApplication::translate("QWebPage", "Play movie in full-screen mode", "Media controller element"); - if (name == "SeekForwardButton") - return QCoreApplication::translate("QWebPage", "Seek quickly back", "Media controller element"); - if (name == "SeekBackButton") - return QCoreApplication::translate("QWebPage", "Seek quickly forward", "Media controller element"); - - ASSERT_NOT_REACHED(); - return String(); -} - -String PlatformStrategiesQt::localizedMediaTimeDescription(float time) -{ - if (!isfinite(time)) - return QCoreApplication::translate("QWebPage", "Indefinite time", "Media time description"); - - int seconds = (int)fabsf(time); - int days = seconds / (60 * 60 * 24); - int hours = seconds / (60 * 60); - int minutes = (seconds / 60) % 60; - seconds %= 60; - - if (days) - return QCoreApplication::translate("QWebPage", "%1 days %2 hours %3 minutes %4 seconds", "Media time description").arg(days).arg(hours).arg(minutes).arg(seconds); - - if (hours) - return QCoreApplication::translate("QWebPage", "%1 hours %2 minutes %3 seconds", "Media time description").arg(hours).arg(minutes).arg(seconds); - - if (minutes) - return QCoreApplication::translate("QWebPage", "%1 minutes %2 seconds", "Media time description").arg(minutes).arg(seconds); - - return QCoreApplication::translate("QWebPage", "%1 seconds", "Media time description").arg(seconds); -} - -#else // ENABLE(VIDEO) -// FIXME: #if ENABLE(VIDEO) should be in the base class - -String PlatformStrategiesQt::localizedMediaControlElementString(const String& name) -{ - return String(); -} - -String PlatformStrategiesQt::localizedMediaControlElementHelpText(const String& name) -{ - return String(); -} - -String PlatformStrategiesQt::localizedMediaTimeDescription(float time) -{ - return String(); -} - -#endif // ENABLE(VIDEO) - - -String PlatformStrategiesQt::validationMessageValueMissingText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::validationMessageTypeMismatchText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::validationMessagePatternMismatchText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::validationMessageTooLongText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::validationMessageRangeUnderflowText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::validationMessageRangeOverflowText() -{ - notImplemented(); - return String(); -} - -String PlatformStrategiesQt::validationMessageStepMismatchText() -{ - notImplemented(); - return String(); -} - - // VisitedLinkStrategy bool PlatformStrategiesQt::isLinkVisited(Page* page, LinkHash hash, const KURL& baseURL, const AtomicString& attributeURL) diff --git a/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.h b/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.h index 504919e38..9dd7e79cf 100644 --- a/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.h +++ b/Source/WebKit/qt/WebCoreSupport/PlatformStrategiesQt.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 Apple Inc. All rights reserved. + * Copyright (C) 2010, 2012 Apple Inc. All rights reserved. * Copyright (C) 2010 INdT - Instituto Nokia de Tecnologia * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) * @@ -29,16 +29,16 @@ #define PlatformStrategiesQt_h #include <CookiesStrategy.h> -#include <LocalizationStrategy.h> #include <PlatformStrategies.h> #include <PluginStrategy.h> #include <VisitedLinkStrategy.h> namespace WebCore { class Page; +class PasteboardStrategy; } -class PlatformStrategiesQt : public WebCore::PlatformStrategies, private WebCore::CookiesStrategy, private WebCore::PluginStrategy, private WebCore::LocalizationStrategy, private WebCore::VisitedLinkStrategy { +class PlatformStrategiesQt : public WebCore::PlatformStrategies, private WebCore::CookiesStrategy, private WebCore::PluginStrategy, private WebCore::VisitedLinkStrategy { public: static void initialize(); @@ -48,8 +48,8 @@ private: // WebCore::PlatformStrategies virtual WebCore::CookiesStrategy* createCookiesStrategy(); virtual WebCore::PluginStrategy* createPluginStrategy(); - virtual WebCore::LocalizationStrategy* createLocalizationStrategy(); virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy(); + virtual WebCore::PasteboardStrategy* createPasteboardStrategy(); // WebCore::CookiesStrategy virtual void notifyCookiesChanged(); @@ -58,101 +58,6 @@ private: virtual void refreshPlugins(); virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&); - // WebCore::LocalizationStrategy - virtual WTF::String inputElementAltText(); - virtual WTF::String resetButtonDefaultLabel(); - virtual WTF::String searchableIndexIntroduction(); - virtual WTF::String submitButtonDefaultLabel(); - virtual WTF::String fileButtonChooseFileLabel(); - virtual WTF::String fileButtonChooseMultipleFilesLabel(); - virtual WTF::String fileButtonNoFileSelectedLabel(); - virtual WTF::String fileButtonNoFilesSelectedLabel(); - virtual WTF::String defaultDetailsSummaryText(); - virtual WTF::String contextMenuItemTagOpenLinkInNewWindow(); - virtual WTF::String contextMenuItemTagDownloadLinkToDisk(); - virtual WTF::String contextMenuItemTagCopyLinkToClipboard(); - virtual WTF::String contextMenuItemTagOpenImageInNewWindow(); - virtual WTF::String contextMenuItemTagDownloadImageToDisk(); - virtual WTF::String contextMenuItemTagCopyImageToClipboard(); - virtual WTF::String contextMenuItemTagCopyImageUrlToClipboard(); - virtual WTF::String contextMenuItemTagOpenFrameInNewWindow(); - virtual WTF::String contextMenuItemTagCopy(); - virtual WTF::String contextMenuItemTagGoBack(); - virtual WTF::String contextMenuItemTagGoForward(); - virtual WTF::String contextMenuItemTagStop(); - virtual WTF::String contextMenuItemTagReload(); - virtual WTF::String contextMenuItemTagCut(); - virtual WTF::String contextMenuItemTagPaste(); - virtual WTF::String contextMenuItemTagSelectAll(); - virtual WTF::String contextMenuItemTagNoGuessesFound(); - virtual WTF::String contextMenuItemTagIgnoreSpelling(); - virtual WTF::String contextMenuItemTagLearnSpelling(); - virtual WTF::String contextMenuItemTagSearchWeb(); - virtual WTF::String contextMenuItemTagLookUpInDictionary(const String&); - virtual WTF::String contextMenuItemTagOpenLink(); - virtual WTF::String contextMenuItemTagIgnoreGrammar(); - virtual WTF::String contextMenuItemTagSpellingMenu(); - virtual WTF::String contextMenuItemTagShowSpellingPanel(bool show); - virtual WTF::String contextMenuItemTagCheckSpelling(); - virtual WTF::String contextMenuItemTagCheckSpellingWhileTyping(); - virtual WTF::String contextMenuItemTagCheckGrammarWithSpelling(); - virtual WTF::String contextMenuItemTagFontMenu(); - virtual WTF::String contextMenuItemTagBold(); - virtual WTF::String contextMenuItemTagItalic(); - virtual WTF::String contextMenuItemTagUnderline(); - virtual WTF::String contextMenuItemTagOutline(); - virtual WTF::String contextMenuItemTagWritingDirectionMenu(); - virtual WTF::String contextMenuItemTagTextDirectionMenu(); - virtual WTF::String contextMenuItemTagDefaultDirection(); - virtual WTF::String contextMenuItemTagLeftToRight(); - virtual WTF::String contextMenuItemTagRightToLeft(); - virtual WTF::String contextMenuItemTagInspectElement(); - virtual WTF::String contextMenuItemTagOpenVideoInNewWindow(); - virtual WTF::String contextMenuItemTagOpenAudioInNewWindow(); - virtual WTF::String contextMenuItemTagCopyVideoLinkToClipboard(); - virtual WTF::String contextMenuItemTagCopyAudioLinkToClipboard(); - virtual WTF::String contextMenuItemTagToggleMediaControls(); - virtual WTF::String contextMenuItemTagToggleMediaLoop(); - virtual WTF::String contextMenuItemTagEnterVideoFullscreen(); - virtual WTF::String contextMenuItemTagMediaPlay(); - virtual WTF::String contextMenuItemTagMediaPause(); - virtual WTF::String contextMenuItemTagMediaMute(); - virtual WTF::String searchMenuNoRecentSearchesText(); - virtual WTF::String searchMenuRecentSearchesText(); - virtual WTF::String searchMenuClearRecentSearchesText(); - virtual WTF::String AXWebAreaText(); - virtual WTF::String AXLinkText(); - virtual WTF::String AXListMarkerText(); - virtual WTF::String AXImageMapText(); - virtual WTF::String AXHeadingText(); - virtual WTF::String AXDefinitionListTermText(); - virtual WTF::String AXDefinitionListDefinitionText(); - virtual WTF::String AXButtonActionVerb(); - virtual WTF::String AXRadioButtonActionVerb(); - virtual WTF::String AXTextFieldActionVerb(); - virtual WTF::String AXCheckedCheckBoxActionVerb(); - virtual WTF::String AXUncheckedCheckBoxActionVerb(); - virtual WTF::String AXMenuListActionVerb(); - virtual WTF::String AXMenuListPopupActionVerb(); - virtual WTF::String AXLinkActionVerb(); - virtual WTF::String missingPluginText(); - virtual WTF::String crashedPluginText(); - virtual WTF::String multipleFileUploadText(unsigned numberOfFiles); - virtual WTF::String unknownFileSizeText(); - virtual WTF::String imageTitle(const WTF::String& filename, const WebCore::IntSize&); - virtual WTF::String mediaElementLoadingStateText(); - virtual WTF::String mediaElementLiveBroadcastStateText(); - virtual WTF::String localizedMediaControlElementString(const WTF::String&); - virtual WTF::String localizedMediaControlElementHelpText(const WTF::String&); - virtual WTF::String localizedMediaTimeDescription(float); - virtual WTF::String validationMessageValueMissingText(); - virtual WTF::String validationMessageTypeMismatchText(); - virtual WTF::String validationMessagePatternMismatchText(); - virtual WTF::String validationMessageTooLongText(); - virtual WTF::String validationMessageRangeUnderflowText(); - virtual WTF::String validationMessageRangeOverflowText(); - virtual WTF::String validationMessageStepMismatchText(); - // WebCore::VisitedLinkStrategy virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::KURL& baseURL, const WTF::AtomicString& attributeURL); virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash); diff --git a/Source/WebKit/qt/WebCoreSupport/TextCheckerClientQt.h b/Source/WebKit/qt/WebCoreSupport/TextCheckerClientQt.h index e78ce1d10..ae419b250 100644 --- a/Source/WebKit/qt/WebCoreSupport/TextCheckerClientQt.h +++ b/Source/WebKit/qt/WebCoreSupport/TextCheckerClientQt.h @@ -47,7 +47,7 @@ public: virtual String getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord); virtual void checkGrammarOfString(const UChar*, int length, Vector<GrammarDetail>&, int* badGrammarLocation, int* badGrammarLength); virtual void getGuessesForWord(const String& word, const String& context, Vector<String>& guesses); - virtual void requestCheckingOfString(SpellChecker*, int, TextCheckingTypeMask, const String&) { } + virtual void requestCheckingOfString(SpellChecker*, const TextCheckingRequest&) { } virtual bool isContinousSpellCheckingEnabled(); virtual void toggleContinousSpellChecking(); diff --git a/Source/WebKit/qt/WebCoreSupport/WebEventConversion.cpp b/Source/WebKit/qt/WebCoreSupport/WebEventConversion.cpp new file mode 100644 index 000000000..be5f5298e --- /dev/null +++ b/Source/WebKit/qt/WebCoreSupport/WebEventConversion.cpp @@ -0,0 +1,237 @@ +/* + Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies) + Copyright (C) 2006 Zack Rusin <zack@kde.org> + Copyright (C) 2011 Research In Motion Limited. + + 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 "WebEventConversion.h" + +#include "PlatformMouseEvent.h" +#include "PlatformWheelEvent.h" +#include <QApplication> +#include <QGraphicsSceneMouseEvent> +#include <QWheelEvent> +#include <wtf/CurrentTime.h> + +namespace WebCore { + +static void mouseEventModifiersFromQtKeyboardModifiers(Qt::KeyboardModifiers keyboardModifiers, unsigned& modifiers) +{ + modifiers = 0; + if (keyboardModifiers & Qt::ShiftModifier) + modifiers |= PlatformEvent::ShiftKey; + if (keyboardModifiers & Qt::ControlModifier) + modifiers |= PlatformEvent::CtrlKey; + if (keyboardModifiers & Qt::AltModifier) + modifiers |= PlatformEvent::AltKey; + if (keyboardModifiers & Qt::MetaModifier) + modifiers |= PlatformEvent::MetaKey; +} + +static void mouseEventTypeAndMouseButtonFromQEvent(const QEvent* event, PlatformEvent::Type& mouseEventType, MouseButton& mouseButton) +{ + enum { MouseEvent, GraphicsSceneMouseEvent } frameworkMouseEventType; + switch (event->type()) { + case QEvent::MouseButtonDblClick: + case QEvent::MouseButtonPress: + frameworkMouseEventType = MouseEvent; + mouseEventType = PlatformEvent::MousePressed; + break; + case QEvent::MouseButtonRelease: + frameworkMouseEventType = MouseEvent; + mouseEventType = PlatformEvent::MouseReleased; + break; + case QEvent::MouseMove: + frameworkMouseEventType = MouseEvent; + mouseEventType = PlatformEvent::MouseMoved; + break; + case QEvent::GraphicsSceneMouseDoubleClick: + case QEvent::GraphicsSceneMousePress: + frameworkMouseEventType = GraphicsSceneMouseEvent; + mouseEventType = PlatformEvent::MousePressed; + break; + case QEvent::GraphicsSceneMouseRelease: + frameworkMouseEventType = GraphicsSceneMouseEvent; + mouseEventType = PlatformEvent::MouseReleased; + break; + case QEvent::GraphicsSceneMouseMove: + frameworkMouseEventType = GraphicsSceneMouseEvent; + mouseEventType = PlatformEvent::MouseMoved; + break; + default: + ASSERT_NOT_REACHED(); + frameworkMouseEventType = MouseEvent; + mouseEventType = PlatformEvent::MouseMoved; + break; + } + + Qt::MouseButtons mouseButtons; + switch (frameworkMouseEventType) { + case MouseEvent: { + const QMouseEvent* mouseEvent = static_cast<const QMouseEvent*>(event); + mouseButtons = mouseEventType == PlatformEvent::MouseMoved ? mouseEvent->buttons() : mouseEvent->button(); + break; + } + case GraphicsSceneMouseEvent: { + const QGraphicsSceneMouseEvent* mouseEvent = static_cast<const QGraphicsSceneMouseEvent*>(event); + mouseButtons = mouseEventType == PlatformEvent::MouseMoved ? mouseEvent->buttons() : mouseEvent->button(); + break; + } + } + + if (mouseButtons & Qt::LeftButton) + mouseButton = LeftButton; + else if (mouseButtons & Qt::RightButton) + mouseButton = RightButton; + else if (mouseButtons & Qt::MidButton) + mouseButton = MiddleButton; + else + mouseButton = NoButton; +} + +class WebKitPlatformMouseEvent : public PlatformMouseEvent { +public: + WebKitPlatformMouseEvent(QGraphicsSceneMouseEvent*, int clickCount); + WebKitPlatformMouseEvent(QInputEvent*, int clickCount); +}; + +WebKitPlatformMouseEvent::WebKitPlatformMouseEvent(QGraphicsSceneMouseEvent* event, int clickCount) +{ + m_timestamp = WTF::currentTime(); + + // FIXME: Why don't we handle a context menu event here as we do in PlatformMouseEvent(QInputEvent*, int)? + // See <https://bugs.webkit.org/show_bug.cgi?id=60728>. + PlatformEvent::Type type; + mouseEventTypeAndMouseButtonFromQEvent(event, type, m_button); + + m_type = type; + m_position = IntPoint(event->pos().toPoint()); + m_globalPosition = IntPoint(event->screenPos()); + + m_clickCount = clickCount; + mouseEventModifiersFromQtKeyboardModifiers(event->modifiers(), m_modifiers); +} + +WebKitPlatformMouseEvent::WebKitPlatformMouseEvent(QInputEvent* event, int clickCount) +{ + m_timestamp = WTF::currentTime(); + + bool isContextMenuEvent = false; +#ifndef QT_NO_CONTEXTMENU + if (event->type() == QEvent::ContextMenu) { + isContextMenuEvent = true; + m_type = PlatformEvent::MousePressed; + QContextMenuEvent* ce = static_cast<QContextMenuEvent*>(event); + m_position = IntPoint(ce->pos()); + m_globalPosition = IntPoint(ce->globalPos()); + m_button = RightButton; + } +#endif + if (!isContextMenuEvent) { + PlatformEvent::Type type; + mouseEventTypeAndMouseButtonFromQEvent(event, type, m_button); + QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event); + + m_type = type; + m_position = IntPoint(mouseEvent->pos()); + m_globalPosition = IntPoint(mouseEvent->globalPos()); + } + + m_clickCount = clickCount; + mouseEventModifiersFromQtKeyboardModifiers(event->modifiers(), m_modifiers); +} + +PlatformMouseEvent convertMouseEvent(QInputEvent* event, int clickCount) +{ + return WebKitPlatformMouseEvent(event, clickCount); +} + +PlatformMouseEvent convertMouseEvent(QGraphicsSceneMouseEvent* event, int clickCount) +{ + return WebKitPlatformMouseEvent(event, clickCount); +} + +class WebKitPlatformWheelEvent : public PlatformWheelEvent { +public: + WebKitPlatformWheelEvent(QGraphicsSceneWheelEvent*); + WebKitPlatformWheelEvent(QWheelEvent*); + +private: + void applyDelta(int delta, Qt::Orientation); +}; + +void WebKitPlatformWheelEvent::applyDelta(int delta, Qt::Orientation orientation) +{ + // A delta that is not mod 120 indicates a device that is sending + // fine-resolution scroll events, so use the delta as number of wheel ticks + // and number of pixels to scroll.See also webkit.org/b/29601 + bool fullTick = !(delta % 120); + + if (orientation == Qt::Horizontal) { + m_deltaX = (fullTick) ? delta / 120.0f : delta; + m_deltaY = 0; + } else { + m_deltaX = 0; + m_deltaY = (fullTick) ? delta / 120.0f : delta; + } + + m_wheelTicksX = m_deltaX; + m_wheelTicksY = m_deltaY; + + // Use the same single scroll step as QTextEdit + // (in QTextEditPrivate::init [h,v]bar->setSingleStep) + static const float cDefaultQtScrollStep = 20.f; + m_deltaX *= (fullTick) ? QApplication::wheelScrollLines() * cDefaultQtScrollStep : 1; + m_deltaY *= (fullTick) ? QApplication::wheelScrollLines() * cDefaultQtScrollStep : 1; +} + +WebKitPlatformWheelEvent::WebKitPlatformWheelEvent(QGraphicsSceneWheelEvent* e) +{ + m_timestamp = WTF::currentTime(); + mouseEventModifiersFromQtKeyboardModifiers(e->modifiers(), m_modifiers); + m_position = e->pos().toPoint(); + m_globalPosition = e->screenPos(); + m_granularity = ScrollByPixelWheelEvent; + m_directionInvertedFromDevice = false; + applyDelta(e->delta(), e->orientation()); +} + +WebKitPlatformWheelEvent::WebKitPlatformWheelEvent(QWheelEvent* e) +{ + m_timestamp = WTF::currentTime(); + mouseEventModifiersFromQtKeyboardModifiers(e->modifiers(), m_modifiers); + m_position = e->pos(); + m_globalPosition = e->globalPos(); + m_granularity = ScrollByPixelWheelEvent; + m_directionInvertedFromDevice = false; + applyDelta(e->delta(), e->orientation()); +} + + +PlatformWheelEvent convertWheelEvent(QWheelEvent* event) +{ + return WebKitPlatformWheelEvent(event); +} + +PlatformWheelEvent convertWheelEvent(QGraphicsSceneWheelEvent* event) +{ + return WebKitPlatformWheelEvent(event); +} + +} diff --git a/Source/WebKit/qt/WebCoreSupport/WebEventConversion.h b/Source/WebKit/qt/WebCoreSupport/WebEventConversion.h new file mode 100644 index 000000000..25d02df22 --- /dev/null +++ b/Source/WebKit/qt/WebCoreSupport/WebEventConversion.h @@ -0,0 +1,41 @@ +/* + Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies) + Copyright (C) 2006 Zack Rusin <zack@kde.org> + Copyright (C) 2011 Research In Motion Limited. + + 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 <qglobal.h> + +QT_BEGIN_NAMESPACE +class QInputEvent; +class QGraphicsSceneMouseEvent; +class QWheelEvent; +class QGraphicsSceneWheelEvent; +QT_END_NAMESPACE + +namespace WebCore { + +class PlatformMouseEvent; +class PlatformWheelEvent; + +PlatformMouseEvent convertMouseEvent(QInputEvent*, int clickCount); +PlatformMouseEvent convertMouseEvent(QGraphicsSceneMouseEvent*, int clickCount); +PlatformWheelEvent convertWheelEvent(QWheelEvent*); +PlatformWheelEvent convertWheelEvent(QGraphicsSceneWheelEvent*); + +} diff --git a/Source/WebKit/qt/declarative/experimental/plugin.cpp b/Source/WebKit/qt/declarative/experimental/plugin.cpp index 7a41657ac..da228521f 100644 --- a/Source/WebKit/qt/declarative/experimental/plugin.cpp +++ b/Source/WebKit/qt/declarative/experimental/plugin.cpp @@ -46,6 +46,9 @@ class WebKitQmlExperimentalExtensionPlugin: public QDeclarativeExtensionPlugin { public: virtual void registerTypes(const char* uri) { + qWarning("\nWARNING: This project is using the experimental QML API extensions for QtWebKit and is therefore tied to a specific QtWebKit release.\n" + "WARNING: The experimental API will change from version to version, or even be removed. You have been warned!\n"); + Q_ASSERT(QLatin1String(uri) == QLatin1String("QtWebKit.experimental")); qmlRegisterUncreatableType<QWebDownloadItem>(uri, 1, 0, "DownloadItem", QObject::tr("Cannot create separate instance of DownloadItem")); diff --git a/Source/WebKit/qt/declarative/plugin.cpp b/Source/WebKit/qt/declarative/plugin.cpp index 64638e469..e2f0fb3ec 100644 --- a/Source/WebKit/qt/declarative/plugin.cpp +++ b/Source/WebKit/qt/declarative/plugin.cpp @@ -25,6 +25,7 @@ #if defined(HAVE_WEBKIT2) #include "qquickwebpage_p.h" #include "qquickwebview_p.h" +#include "qtwebsecurityorigin_p.h" #include "qwebiconimageprovider_p.h" #include "qwebnavigationrequest_p.h" #include "qwebpermissionrequest_p.h" @@ -65,6 +66,8 @@ public: qmlRegisterUncreatableType<QNetworkReply>(uri, 3, 0, "NetworkReply", QObject::tr("Cannot create separate instance of NetworkReply")); qmlRegisterUncreatableType<QWebPermissionRequest>(uri, 3, 0, "PermissionRequest", QObject::tr("Cannot create separate instance of PermissionRequest")); qmlRegisterUncreatableType<QWebNavigationRequest>(uri, 3, 0, "NavigationRequest", QObject::tr("Cannot create separate instance of NavigationRequest")); + qmlRegisterUncreatableType<QtWebSecurityOrigin>(uri, 3, 0, "SecurityOrigin", QObject::tr("Cannot create separate instance of SecurityOrigin")); + #endif } }; diff --git a/Source/WebKit/qt/tests/benchmarks/loading/tst_loading.cpp b/Source/WebKit/qt/tests/benchmarks/loading/tst_loading.cpp index 661a7e3cb..1c3985b83 100644 --- a/Source/WebKit/qt/tests/benchmarks/loading/tst_loading.cpp +++ b/Source/WebKit/qt/tests/benchmarks/loading/tst_loading.cpp @@ -25,28 +25,7 @@ #include <qwebview.h> #include <qpainter.h> -/** - * Starts an event loop that runs until the given signal is received. - Optionally the event loop - * can return earlier on a timeout. - * - * \return \p true if the requested signal was received - * \p false on timeout - */ -static bool waitForSignal(QObject* obj, const char* signal, int timeout = 0) -{ - QEventLoop loop; - QObject::connect(obj, signal, &loop, SLOT(quit())); - QTimer timer; - QSignalSpy timeoutSpy(&timer, SIGNAL(timeout())); - if (timeout > 0) { - QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - timer.setSingleShot(true); - timer.start(timeout); - } - loop.exec(); - return timeoutSpy.isEmpty(); -} +#include "util.h" class tst_Loading : public QObject { @@ -96,13 +75,13 @@ void tst_Loading::load() QFETCH(QUrl, url); if (!m_manager.isOnline()) - QSKIP("This test requires an active network connection", SkipSingle); + W_QSKIP("This test requires an active network connection", SkipSingle); QBENCHMARK { m_view->load(url); // really wait for loading, painting is in another test - ::waitForSignal(m_view, SIGNAL(loadFinished(bool))); + ::waitForSignal(m_view, SIGNAL(loadFinished(bool)), 0); } } diff --git a/Source/WebKit/qt/tests/benchmarks/painting/tst_painting.cpp b/Source/WebKit/qt/tests/benchmarks/painting/tst_painting.cpp index 47d34dcbd..3f97b5aea 100644 --- a/Source/WebKit/qt/tests/benchmarks/painting/tst_painting.cpp +++ b/Source/WebKit/qt/tests/benchmarks/painting/tst_painting.cpp @@ -26,28 +26,7 @@ #include <qwebview.h> #include <qpainter.h> -/** - * Starts an event loop that runs until the given signal is received. - Optionally the event loop - * can return earlier on a timeout. - * - * \return \p true if the requested signal was received - * \p false on timeout - */ -static bool waitForSignal(QObject* obj, const char* signal, int timeout = 0) -{ - QEventLoop loop; - QObject::connect(obj, signal, &loop, SLOT(quit())); - QTimer timer; - QSignalSpy timeoutSpy(&timer, SIGNAL(timeout())); - if (timeout > 0) { - QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - timer.setSingleShot(true); - timer.start(timeout); - } - loop.exec(); - return timeoutSpy.isEmpty(); -} +#include "util.h" class tst_Painting : public QObject { @@ -96,10 +75,10 @@ void tst_Painting::paint() QFETCH(QUrl, url); if (!m_manager.isOnline()) - QSKIP("This test requires an active network connection", SkipSingle); + W_QSKIP("This test requires an active network connection", SkipSingle); m_view->load(url); - ::waitForSignal(m_view, SIGNAL(loadFinished(bool))); + ::waitForSignal(m_view, SIGNAL(loadFinished(bool)), 0); /* force a layout */ QWebFrame* mainFrame = m_page->mainFrame(); @@ -116,7 +95,7 @@ void tst_Painting::paint() void tst_Painting::textAreas() { m_view->load(QUrl("data:text/html;<html><body></body></html>")); - ::waitForSignal(m_view, SIGNAL(loadFinished(bool))); + ::waitForSignal(m_view, SIGNAL(loadFinished(bool)), 0); QWebElement bodyElement = m_page->mainFrame()->findFirstElement("body"); diff --git a/Source/WebKit/qt/tests/qdeclarativewebview/tst_qdeclarativewebview.cpp b/Source/WebKit/qt/tests/qdeclarativewebview/tst_qdeclarativewebview.cpp index 1f9a2ff84..f9421e3cf 100644 --- a/Source/WebKit/qt/tests/qdeclarativewebview/tst_qdeclarativewebview.cpp +++ b/Source/WebKit/qt/tests/qdeclarativewebview/tst_qdeclarativewebview.cpp @@ -139,7 +139,7 @@ void tst_QDeclarativeWebView::basicProperties() void tst_QDeclarativeWebView::elementAreaAt() { - QSKIP("This test should be changed to test 'heuristicZoom' instead.", SkipAll); + W_QSKIP("This test should be changed to test 'heuristicZoom' instead.", SkipAll); QDeclarativeEngine engine; QDeclarativeComponent component(&engine, QUrl("qrc:///resources/elements.qml")); checkNoErrors(component); diff --git a/Source/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp b/Source/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp index 3eb08c450..2c28aef1f 100644 --- a/Source/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp +++ b/Source/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp @@ -2555,7 +2555,7 @@ void tst_QWebFrame::setHtmlWithBaseURL() // As we are using a local file as baseUrl, its security origin should be able to load local resources. if (!QDir(TESTS_SOURCE_DIR).exists()) - QSKIP(QString("This test requires access to resources found in '%1'").arg(TESTS_SOURCE_DIR).toLatin1().constData(), SkipAll); + W_QSKIP(QString("This test requires access to resources found in '%1'").arg(TESTS_SOURCE_DIR).toLatin1().constData(), SkipAll); QDir::setCurrent(TESTS_SOURCE_DIR); diff --git a/Source/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp b/Source/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp index b3ff3b9c1..b6f0aeee3 100644 --- a/Source/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp +++ b/Source/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp @@ -160,7 +160,9 @@ private slots: void testStopScheduledPageRefresh(); void findText(); void supportedContentType(); - void infiniteLoopJS(); + // [Qt] tst_QWebPage::infiniteLoopJS() timeouts with DFG JIT + // https://bugs.webkit.org/show_bug.cgi?id=79040 + // void infiniteLoopJS(); void navigatorCookieEnabled(); void deleteQWebViewTwice(); void renderOnRepaintRequestedShouldNotRecurse(); @@ -284,6 +286,9 @@ private: bool m_allowGeolocation; }; +// [Qt] tst_QWebPage::infiniteLoopJS() timeouts with DFG JIT +// https://bugs.webkit.org/show_bug.cgi?id=79040 +/* void tst_QWebPage::infiniteLoopJS() { JSTestPage* newPage = new JSTestPage(m_view); @@ -292,6 +297,7 @@ void tst_QWebPage::infiniteLoopJS() m_view->page()->mainFrame()->evaluateJavaScript("var run = true;var a = 1;while(run){a++;}"); delete newPage; } +*/ void tst_QWebPage::geolocationRequestJS() { @@ -299,7 +305,7 @@ void tst_QWebPage::geolocationRequestJS() if (newPage->mainFrame()->evaluateJavaScript(QLatin1String("!navigator.geolocation")).toBool()) { delete newPage; - QSKIP("Geolocation is not supported.", SkipSingle); + W_QSKIP("Geolocation is not supported.", SkipSingle); } connect(newPage, SIGNAL(featurePermissionRequested(QWebFrame*, QWebPage::Feature)), @@ -529,7 +535,7 @@ void tst_QWebPage::loadHtml5Video() QEXPECT_FAIL("", "https://bugs.webkit.org/show_bug.cgi?id=65452", Continue); QCOMPARE(mUrl.toEncoded(), url); #else - QSKIP("This test requires Qt Multimedia", SkipAll); + W_QSKIP("This test requires Qt Multimedia", SkipAll); #endif } @@ -2738,7 +2744,7 @@ void tst_QWebPage::screenshot_data() void tst_QWebPage::screenshot() { if (!QDir(TESTS_SOURCE_DIR).exists()) - QSKIP(QString("This test requires access to resources found in '%1'").arg(TESTS_SOURCE_DIR).toLatin1().constData(), SkipAll); + W_QSKIP(QString("This test requires access to resources found in '%1'").arg(TESTS_SOURCE_DIR).toLatin1().constData(), SkipAll); QDir::setCurrent(TESTS_SOURCE_DIR); diff --git a/Source/WebKit/qt/tests/qwebview/tst_qwebview.cpp b/Source/WebKit/qt/tests/qwebview/tst_qwebview.cpp index be2c4c985..f7dc9c5f4 100644 --- a/Source/WebKit/qt/tests/qwebview/tst_qwebview.cpp +++ b/Source/WebKit/qt/tests/qwebview/tst_qwebview.cpp @@ -133,7 +133,7 @@ void tst_QWebView::reusePage_data() void tst_QWebView::reusePage() { if (!QDir(TESTS_SOURCE_DIR).exists()) - QSKIP(QString("This test requires access to resources found in '%1'").arg(TESTS_SOURCE_DIR).toLatin1().constData(), SkipAll); + W_QSKIP(QString("This test requires access to resources found in '%1'").arg(TESTS_SOURCE_DIR).toLatin1().constData(), SkipAll); QDir::setCurrent(TESTS_SOURCE_DIR); diff --git a/Source/WebKit/qt/tests/util.h b/Source/WebKit/qt/tests/util.h index 94628ca9c..22192bad2 100644 --- a/Source/WebKit/qt/tests/util.h +++ b/Source/WebKit/qt/tests/util.h @@ -77,4 +77,9 @@ static bool waitForSignal(QObject* obj, const char* signal, int timeout = 10000) } \ QCOMPARE(__expr, __expected); \ } while(0) + +// Compatibility for Qt5 +#define W_QSKIP(a, b) QSKIP(a, b) +#else +#define W_QSKIP(a, b) QSKIP(a) #endif diff --git a/Source/WebKit/win/ChangeLog b/Source/WebKit/win/ChangeLog index 32db318fa..1c7f320a2 100644 --- a/Source/WebKit/win/ChangeLog +++ b/Source/WebKit/win/ChangeLog @@ -1,3 +1,138 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/WebEditorClient.h: + (WebEditorClient::requestCheckingOfString): + (WebEditorClient): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/WebEditorClient.cpp: + (WebEditorClient::shouldApplyStyle): + * WebCoreSupport/WebEditorClient.h: + (WebEditorClient): + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/WebEditorClient.cpp: + (WebEditorClient::shouldApplyStyle): + * WebCoreSupport/WebEditorClient.h: + (WebEditorClient): + +2012-02-17 Kalev Lember <kalevlember@gmail.com> + + Remove unused parameters from WTF threading API + https://bugs.webkit.org/show_bug.cgi?id=78389 + + Reviewed by Adam Roben. + + waitForThreadCompletion() had an out param 'void **result' to get the + 'void *' returned by ThreadFunction. However, the implementation in + ThreadingWin.cpp ignored the out param, not filling it in. This had + led to a situation where none of the client code made use of the param + and just ignored it. + + To clean this up, the patch changes the signature of ThreadFunction to + return void instead of void* and drops the the unused 'void **result' + parameter from waitForThreadCompletion. Also, all client code is + updated for the API change. + + As mentioned in https://bugs.webkit.org/show_bug.cgi?id=78389 , even + though the change only affects internal API, Safari is using it + directly and we'll need to keep the old versions around for ABI + compatibility. For this, the patch adds compatibility wrappers with + the old ABI. + + * WebKit.vcproj/WebKit_Cairo.def: Add the new functions. + * WebKit.vcproj/WebKit_Cairo_debug.def: Ditto. + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebCoreSupport/WebChromeClient.h: + (WebChromeClient::numTouchEventHandlersChanged): + +2012-02-14 Alexey Proskuryakov <ap@apple.com> + + [Mac][Win][WK2] Switch to RFC 6455 protocol for WebSockets + https://bugs.webkit.org/show_bug.cgi?id=78541 + <rdar://problem/10036695> + + Reviewed by Kent Tamura. + + * WebPreferences.cpp: (WebPreferences::initializeDefaultSettings): Changed default value of + the preference + +2012-02-11 Nikolas Zimmermann <nzimmermann@rim.com> + + Convert svg/animations to use SMIL methods for driving the timeline + https://bugs.webkit.org/show_bug.cgi?id=78422 + + Reviewed by Dirk Schulze. + + Remove SVG animation sampling functionality provided for DRT, which no longer uses it. + Instead we switched the svg/animations tests to use SVGSVGElement.setCurrentTime. + + * Interfaces/IWebFramePrivate.idl: + * WebFrame.cpp: + * WebFrame.h: + +2012-02-13 Andy Estes <aestes@apple.com> + + Fix the Windows build. + + * WebCoreSupport/WebPlatformStrategies.cpp: + (WebPlatformStrategies::createPasteboardStrategy): + * WebCoreSupport/WebPlatformStrategies.h: + (WebPlatformStrategies): + +2012-02-12 Andy Estes <aestes@apple.com> + + [Windows] Add API to enable inverted color drawing on a WebView + https://bugs.webkit.org/show_bug.cgi?id=77382 + + Reviewed by Adam Roben. + + Add a new private WebPreference key called "WebKitShouldInvertColors" + and add private cover methods to get and set the preference. When this + preference changes on a WebPreference object, all WebViews listening to + that object will repaint to reflect the new value. + + * Interfaces/IWebPreferencesPrivate.idl: Add [setS|s]houldInvertColors() + cover methods for WebKitShouldInvertColorsPreferenceKey. + * WebPreferenceKeysPrivate.h: Add WebKitShouldInvertColorsPreferenceKey. + * WebPreferences.cpp: + (WebPreferences::shouldInvertColors): + (WebPreferences::setShouldInvertColors): + * WebPreferences.h: + (WebPreferences): + * WebView.cpp: + (WebView::setShouldInvertColors): If m_shouldInvertColors changes, + update the value on the WebView and in m_layerTreeHost, then repaint + the view. + (WebView::notifyPreferencesChanged): + (WebView::setAcceleratedCompositing): When creating a new layer tree + host, tell it whether it should be inverting colors. + * WebView.h: + 2012-02-07 MORITA Hajime <morrita@google.com> Replacement text should be available from the marker. diff --git a/Source/WebKit/win/Interfaces/IWebFramePrivate.idl b/Source/WebKit/win/Interfaces/IWebFramePrivate.idl index 31287ba58..90ba4bdb9 100644 --- a/Source/WebKit/win/Interfaces/IWebFramePrivate.idl +++ b/Source/WebKit/win/Interfaces/IWebFramePrivate.idl @@ -98,8 +98,6 @@ interface IWebFramePrivate : IUnknown HRESULT counterValueForElementById([in] BSTR id, [out, retval] BSTR* result); - HRESULT pauseSVGAnimation([in] BSTR elementId, [in] IDOMNode* node, [in] double secondsFromNow, [out, retval] BOOL* animationWasRunning); - HRESULT visibleContentRect([out, retval] RECT*); HRESULT pageNumberForElementById([in] BSTR id, [in] float pageWidthInPixels, [in] float pageHeightInPixels, [out, retval] int* pageNumber); diff --git a/Source/WebKit/win/Interfaces/IWebPreferencesPrivate.idl b/Source/WebKit/win/Interfaces/IWebPreferencesPrivate.idl index 01ace36d7..ad67a56b0 100644 --- a/Source/WebKit/win/Interfaces/IWebPreferencesPrivate.idl +++ b/Source/WebKit/win/Interfaces/IWebPreferencesPrivate.idl @@ -140,4 +140,6 @@ interface IWebPreferencesPrivate : IUnknown HRESULT setShowsToolTipOverTruncatedText([in] BOOL); HRESULT showsToolTipOverTruncatedText([out, retval] BOOL*); + HRESULT setShouldInvertColors([in] BOOL); + HRESULT shouldInvertColors([out, retval] BOOL*); } diff --git a/Source/WebKit/win/WebCoreSupport/WebChromeClient.h b/Source/WebKit/win/WebCoreSupport/WebChromeClient.h index b6aeb1cf7..2a9a8fe7f 100644 --- a/Source/WebKit/win/WebCoreSupport/WebChromeClient.h +++ b/Source/WebKit/win/WebCoreSupport/WebChromeClient.h @@ -177,6 +177,7 @@ public: virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const { return true; } virtual void numWheelEventHandlersChanged(unsigned) { } + virtual void numTouchEventHandlersChanged(unsigned) { } private: COMPtr<IWebUIDelegate> uiDelegate(); diff --git a/Source/WebKit/win/WebCoreSupport/WebEditorClient.cpp b/Source/WebKit/win/WebCoreSupport/WebEditorClient.cpp index 0b2653095..6a4ee8476 100644 --- a/Source/WebKit/win/WebCoreSupport/WebEditorClient.cpp +++ b/Source/WebKit/win/WebCoreSupport/WebEditorClient.cpp @@ -276,13 +276,13 @@ bool WebEditorClient::shouldInsertText(const String& /*str*/, Range* /* replacin //bool WebEditorClient::shouldChangeSelectedRange(Range *currentRange, Range *toProposedRange, SelectionAffinity selectionAffinity, bool stillSelecting) //{ notImplemented(); return false; } -bool WebEditorClient::shouldApplyStyle(CSSStyleDeclaration* /*style*/, Range* /*toElementsInDOMRange*/) +bool WebEditorClient::shouldApplyStyle(StylePropertySet* /*style*/, Range* /*toElementsInDOMRange*/) { notImplemented(); return true; } bool WebEditorClient::shouldMoveRangeAfterDelete(Range* /*range*/, Range* /*rangeToBeReplaced*/) { notImplemented(); return true; } -bool WebEditorClient::shouldChangeTypingStyle(CSSStyleDeclaration* /*currentStyle*/, CSSStyleDeclaration* /*toProposedStyle*/) +bool WebEditorClient::shouldChangeTypingStyle(StylePropertySet* /*currentStyle*/, StylePropertySet* /*toProposedStyle*/) { notImplemented(); return false; } void WebEditorClient::webViewDidChangeTypingStyle(WebNotification* /*notification*/) diff --git a/Source/WebKit/win/WebCoreSupport/WebEditorClient.h b/Source/WebKit/win/WebCoreSupport/WebEditorClient.h index a40586c98..0f29e9e0f 100644 --- a/Source/WebKit/win/WebCoreSupport/WebEditorClient.h +++ b/Source/WebKit/win/WebCoreSupport/WebEditorClient.h @@ -64,9 +64,9 @@ public: bool shouldDeleteRange(WebCore::Range*); bool shouldInsertNode(WebCore::Node*, WebCore::Range* replacingRange, WebCore::EditorInsertAction); - bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*); + bool shouldApplyStyle(WebCore::StylePropertySet*, WebCore::Range*); bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*); - bool shouldChangeTypingStyle(WebCore::CSSStyleDeclaration* currentStyle, WebCore::CSSStyleDeclaration* toProposedStyle); + bool shouldChangeTypingStyle(WebCore::StylePropertySet* currentStyle, WebCore::StylePropertySet* toProposedStyle); void webViewDidChangeTypingStyle(WebNotification*); void webViewDidChangeSelection(WebNotification*); @@ -110,7 +110,8 @@ public: virtual void willSetInputMethodState(); virtual void setInputMethodState(bool); - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&) {} + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&) { } + virtual WebCore::TextCheckerClient* textChecker() { return this; } private: diff --git a/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.cpp b/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.cpp index 7a3febb92..230f3323f 100644 --- a/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.cpp +++ b/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.cpp @@ -57,6 +57,11 @@ VisitedLinkStrategy* WebPlatformStrategies::createVisitedLinkStrategy() return this; } +PasteboardStrategy* WebPlatformStrategies::createPasteboardStrategy() +{ + return 0; +} + void WebPlatformStrategies::notifyCookiesChanged() { } diff --git a/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.h b/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.h index 509de098b..274124213 100644 --- a/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.h +++ b/Source/WebKit/win/WebCoreSupport/WebPlatformStrategies.h @@ -42,6 +42,7 @@ private: virtual WebCore::CookiesStrategy* createCookiesStrategy(); virtual WebCore::PluginStrategy* createPluginStrategy(); virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy(); + virtual WebCore::PasteboardStrategy* createPasteboardStrategy(); // WebCore::CookiesStrategy virtual void notifyCookiesChanged(); diff --git a/Source/WebKit/win/WebFrame.cpp b/Source/WebKit/win/WebFrame.cpp index f15d3efd5..3564bd986 100644 --- a/Source/WebKit/win/WebFrame.cpp +++ b/Source/WebKit/win/WebFrame.cpp @@ -93,8 +93,6 @@ #include <WebCore/RenderView.h> #include <WebCore/RenderTreeAsText.h> #include <WebCore/Settings.h> -#include <WebCore/SVGDocumentExtensions.h> -#include <WebCore/SVGSMILElement.h> #include <WebCore/TextIterator.h> #include <WebCore/JSDOMBinding.h> #include <WebCore/ScriptController.h> @@ -1276,34 +1274,6 @@ HRESULT WebFrame::pauseTransition(BSTR propertyName, IDOMNode* node, double seco return S_OK; } -HRESULT WebFrame::pauseSVGAnimation(BSTR elementId, IDOMNode* node, double secondsFromNow, BOOL* animationWasRunning) -{ - if (!node || !animationWasRunning) - return E_POINTER; - - *animationWasRunning = FALSE; - - Frame* frame = core(this); - if (!frame) - return E_FAIL; - - Document* document = frame->document(); - if (!document || !document->svgExtensions()) - return E_FAIL; - - COMPtr<DOMNode> domNode(Query, node); - if (!domNode || !SVGSMILElement::isSMILElement(domNode->node())) - return E_FAIL; - -#if ENABLE(SVG) - *animationWasRunning = document->accessSVGExtensions()->sampleAnimationAtTime(String(elementId, SysStringLen(elementId)), static_cast<SVGSMILElement*>(domNode->node()), secondsFromNow); -#else - *animationWasRunning = FALSE; -#endif - - return S_OK; -} - HRESULT WebFrame::visibleContentRect(RECT* rect) { if (!rect) diff --git a/Source/WebKit/win/WebFrame.h b/Source/WebKit/win/WebFrame.h index f777a3205..c6286b0d0 100644 --- a/Source/WebKit/win/WebFrame.h +++ b/Source/WebKit/win/WebFrame.h @@ -259,7 +259,6 @@ public: virtual HRESULT STDMETHODCALLTYPE pauseAnimation(BSTR animationName, IDOMNode*, double secondsFromNow, BOOL* animationWasRunning); virtual HRESULT STDMETHODCALLTYPE pauseTransition(BSTR propertyName, IDOMNode*, double secondsFromNow, BOOL* transitionWasRunning); - virtual HRESULT STDMETHODCALLTYPE pauseSVGAnimation(BSTR elementId, IDOMNode*, double secondsFromNow, BOOL* animationWasRunning); virtual HRESULT STDMETHODCALLTYPE numberOfActiveAnimations(UINT*); virtual HRESULT STDMETHODCALLTYPE suspendAnimations(); virtual HRESULT STDMETHODCALLTYPE resumeAnimations(); diff --git a/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo.def b/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo.def index 89b0a2a61..e4cd266ed 100644 --- a/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo.def +++ b/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo.def @@ -122,6 +122,7 @@ EXPORTS ?broadcast@ThreadCondition@WTF@@QAEXXZ ?callOnMainThread@WTF@@YAXP6AXPAX@Z0@Z ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z + ?createThread@WTF@@YAIP6AXPAX@Z0PBD@Z ?currentThread@WTF@@YAIXZ ?detachThread@WTF@@YAXI@Z ?initializeMainThread@WTF@@YAXXZ @@ -139,5 +140,6 @@ EXPORTS ?unlockAtomicallyInitializedStaticMutex@WTF@@YAXXZ ?updateLayoutIgnorePendingStylesheets@Document@WebCore@@QAEXXZ ?wait@ThreadCondition@WTF@@QAEXAAVMutex@2@@Z + ?waitForThreadCompletion@WTF@@YAHI@Z ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z ?createThread@WTF@@YAIP6APAXPAX@Z0@Z diff --git a/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo_debug.def b/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo_debug.def index 1b1b72df4..e4ac119c2 100644 --- a/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo_debug.def +++ b/Source/WebKit/win/WebKit.vcproj/WebKit_Cairo_debug.def @@ -122,6 +122,7 @@ EXPORTS ?broadcast@ThreadCondition@WTF@@QAEXXZ ?callOnMainThread@WTF@@YAXP6AXPAX@Z0@Z ?createThread@WTF@@YAIP6APAXPAX@Z0PBD@Z + ?createThread@WTF@@YAIP6AXPAX@Z0PBD@Z ?currentThread@WTF@@YAIXZ ?detachThread@WTF@@YAXI@Z ?initializeMainThread@WTF@@YAXXZ @@ -139,5 +140,6 @@ EXPORTS ?unlockAtomicallyInitializedStaticMutex@WTF@@YAXXZ ?updateLayoutIgnorePendingStylesheets@Document@WebCore@@QAEXXZ ?wait@ThreadCondition@WTF@@QAEXAAVMutex@2@@Z + ?waitForThreadCompletion@WTF@@YAHI@Z ?waitForThreadCompletion@WTF@@YAHIPAPAX@Z ?createThread@WTF@@YAIP6APAXPAX@Z0@Z diff --git a/Source/WebKit/win/WebPreferenceKeysPrivate.h b/Source/WebKit/win/WebPreferenceKeysPrivate.h index 76eacffeb..468944657 100644 --- a/Source/WebKit/win/WebPreferenceKeysPrivate.h +++ b/Source/WebKit/win/WebPreferenceKeysPrivate.h @@ -83,6 +83,7 @@ #define WebKitPDFScaleFactorPreferenceKey "WebKitPDFScaleFactor" #define WebKitEditableLinkBehaviorPreferenceKey "WebKitEditableLinkBehavior" #define WebKitEditingBehaviorPreferenceKey "WebKitEditingBehavior" +#define WebKitShouldInvertColorsPreferenceKey "WebKitShouldInvertColors" // Window display is throttled to 60 frames per second if WebKitThrottleWindowDisplayPreferenceKey // is set to YES. The window display throttle is OFF by default for compatibility with Mac OS X diff --git a/Source/WebKit/win/WebPreferences.cpp b/Source/WebKit/win/WebPreferences.cpp index 39e4644c0..6f5ed8e7e 100644 --- a/Source/WebKit/win/WebPreferences.cpp +++ b/Source/WebKit/win/WebPreferences.cpp @@ -268,7 +268,7 @@ void WebPreferences::initializeDefaultSettings() CFDictionaryAddValue(defaults, CFSTR(WebKitMemoryInfoEnabledPreferenceKey), kCFBooleanFalse); CFDictionaryAddValue(defaults, CFSTR(WebKitHyperlinkAuditingEnabledPreferenceKey), kCFBooleanTrue); - CFDictionaryAddValue(defaults, CFSTR(WebKitHixie76WebSocketProtocolEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitHixie76WebSocketProtocolEnabledPreferenceKey), kCFBooleanFalse); CFDictionaryAddValue(defaults, CFSTR(WebKitMediaPlaybackRequiresUserGesturePreferenceKey), kCFBooleanFalse); CFDictionaryAddValue(defaults, CFSTR(WebKitMediaPlaybackAllowsInlinePreferenceKey), kCFBooleanTrue); @@ -1639,6 +1639,21 @@ HRESULT WebPreferences::setShowsToolTipOverTruncatedText(BOOL showsToolTip) return S_OK; } +HRESULT WebPreferences::shouldInvertColors(BOOL* shouldInvertColors) +{ + if (!shouldInvertColors) + return E_POINTER; + + *shouldInvertColors = boolValueForKey(CFSTR(WebKitShouldInvertColorsPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setShouldInvertColors(BOOL shouldInvertColors) +{ + setBoolValue(CFSTR(WebKitShouldInvertColorsPreferenceKey), shouldInvertColors); + return S_OK; +} + void WebPreferences::willAddToWebView() { ++m_numWebViews; diff --git a/Source/WebKit/win/WebPreferences.h b/Source/WebKit/win/WebPreferences.h index 3878050bb..baf56ecd0 100644 --- a/Source/WebKit/win/WebPreferences.h +++ b/Source/WebKit/win/WebPreferences.h @@ -468,6 +468,9 @@ public: virtual HRESULT STDMETHODCALLTYPE showsToolTipOverTruncatedText(BOOL*); virtual HRESULT STDMETHODCALLTYPE setShowsToolTipOverTruncatedText(BOOL); + virtual HRESULT STDMETHODCALLTYPE shouldInvertColors(BOOL*); + virtual HRESULT STDMETHODCALLTYPE setShouldInvertColors(BOOL); + // WebPreferences // This method accesses a different preference key than developerExtrasEnabled. diff --git a/Source/WebKit/win/WebView.cpp b/Source/WebKit/win/WebView.cpp index 57acc1318..5927c9664 100644 --- a/Source/WebKit/win/WebView.cpp +++ b/Source/WebKit/win/WebView.cpp @@ -2072,6 +2072,23 @@ void WebView::setIsBeingDestroyed() ::SetWindowLongPtrW(m_viewWindow, 0, 0); } +void WebView::setShouldInvertColors(bool shouldInvertColors) +{ + if (m_shouldInvertColors == shouldInvertColors) + return; + + m_shouldInvertColors = shouldInvertColors; + +#if USE(ACCELERATED_COMPOSITING) + if (m_layerTreeHost) + m_layerTreeHost->setShouldInvertColors(shouldInvertColors); +#endif + + RECT windowRect = {0}; + frameRect(&windowRect); + repaint(windowRect, true, true); +} + bool WebView::registerWebViewWindowClass() { static bool haveRegisteredWindowClass = false; @@ -4922,6 +4939,11 @@ HRESULT WebView::notifyPreferencesChanged(IWebNotification* notification) return hr; settings->setMediaPlaybackAllowsInline(enabled); + hr = prefsPrivate->shouldInvertColors(&enabled); + if (FAILED(hr)) + return hr; + setShouldInvertColors(enabled); + return S_OK; } @@ -6463,6 +6485,8 @@ void WebView::setAcceleratedCompositing(bool accelerated) if (m_layerTreeHost) { m_isAcceleratedCompositing = true; + m_layerTreeHost->setShouldInvertColors(m_shouldInvertColors); + m_layerTreeHost->setClient(this); ASSERT(m_viewWindow); m_layerTreeHost->setWindow(m_viewWindow); diff --git a/Source/WebKit/win/WebView.h b/Source/WebKit/win/WebView.h index 7d2a6e2f9..30843d366 100644 --- a/Source/WebKit/win/WebView.h +++ b/Source/WebKit/win/WebView.h @@ -1002,6 +1002,7 @@ private: #endif bool m_shouldInvertColors; + void setShouldInvertColors(bool); protected: static bool registerWebViewWindowClass(); diff --git a/Source/WebKit/wince/ChangeLog b/Source/WebKit/wince/ChangeLog index 6d2a7e647..998f5d165 100644 --- a/Source/WebKit/wince/ChangeLog +++ b/Source/WebKit/wince/ChangeLog @@ -1,3 +1,70 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebCoreSupport/EditorClientWinCE.h: + (WebKit::EditorClientWinCE::requestCheckingOfString): + +2012-02-23 Patrick Gansterer <paroga@webkit.org> + + Unreviewed WinCE build fix after r108462. + + * WebCoreSupport/EditorClientWinCE.h: + (EditorClientWinCE): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientWinCE.cpp: + (WebKit::EditorClientWinCE::shouldApplyStyle): + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebCoreSupport/EditorClientWinCE.cpp: + (WebKit::EditorClientWinCE::shouldApplyStyle): + +2012-02-20 Benjamin Poulain <benjamin@webkit.org> + + Get rid of the LocalizationStrategy + https://bugs.webkit.org/show_bug.cgi?id=78324 + + Reviewed by Sam Weinig. + + Remove a useless #include of LocalizationStrategy.h. + + * WebCoreSupport/PlatformStrategiesWinCE.h: + +2012-02-15 Patrick Gansterer <paroga@webkit.org> + + Unreviewed WinCE build fix after r107606. + + * WebCoreSupport/PlatformStrategiesWinCE.cpp: + (PlatformStrategiesWinCE::createPasteboardStrategy): + * WebCoreSupport/PlatformStrategiesWinCE.h: + (PlatformStrategiesWinCE): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebCoreSupport/ChromeClientWinCE.h: + (WebKit::ChromeClientWinCE::numTouchEventHandlersChanged): + 2011-12-19 Sam Weinig <sam@webkit.org> More PlatformEvent cleanup diff --git a/Source/WebKit/wince/WebCoreSupport/ChromeClientWinCE.h b/Source/WebKit/wince/WebCoreSupport/ChromeClientWinCE.h index 006e010f8..613783a03 100644 --- a/Source/WebKit/wince/WebCoreSupport/ChromeClientWinCE.h +++ b/Source/WebKit/wince/WebCoreSupport/ChromeClientWinCE.h @@ -177,6 +177,7 @@ public: virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const { return true; } virtual void numWheelEventHandlersChanged(unsigned) { } + virtual void numTouchEventHandlersChanged(unsigned) { } private: WebView* m_webView; diff --git a/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.cpp b/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.cpp index 4cd3aac18..10c23731c 100644 --- a/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.cpp +++ b/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.cpp @@ -102,7 +102,7 @@ bool EditorClientWinCE::shouldChangeSelectedRange(Range*, Range*, EAffinity, boo return true; } -bool EditorClientWinCE::shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*) +bool EditorClientWinCE::shouldApplyStyle(WebCore::StylePropertySet*, WebCore::Range*) { notImplemented(); return true; diff --git a/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.h b/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.h index c29524e1a..fc9ce023f 100644 --- a/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.h +++ b/Source/WebKit/wince/WebCoreSupport/EditorClientWinCE.h @@ -55,7 +55,7 @@ public: virtual bool shouldInsertText(const WTF::String&, WebCore::Range*, WebCore::EditorInsertAction); virtual bool shouldChangeSelectedRange(WebCore::Range*, WebCore::Range*, WebCore::EAffinity, bool); - virtual bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*); + virtual bool shouldApplyStyle(WebCore::StylePropertySet*, WebCore::Range*); virtual bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*); virtual void didBeginEditing(); @@ -101,7 +101,7 @@ public: virtual void getGuessesForWord(const WTF::String& word, const WTF::String& context, WTF::Vector<WTF::String>& guesses); virtual void willSetInputMethodState(); virtual void setInputMethodState(bool); - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&) {} + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&) { } virtual WebCore::TextCheckerClient* textChecker() { return this; } private: diff --git a/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.cpp b/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.cpp index 3836cbd6a..3f8c907c7 100644 --- a/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.cpp +++ b/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.cpp @@ -58,6 +58,11 @@ VisitedLinkStrategy* PlatformStrategiesWinCE::createVisitedLinkStrategy() return this; } +PasteboardStrategy* PlatformStrategiesWinCE::createPasteboardStrategy() +{ + return 0; +} + void PlatformStrategiesWinCE::notifyCookiesChanged() { } diff --git a/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.h b/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.h index 92d37dc65..344635690 100644 --- a/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.h +++ b/Source/WebKit/wince/WebCoreSupport/PlatformStrategiesWinCE.h @@ -26,7 +26,6 @@ #define PlatformStrategiesWinCE_h #include "CookiesStrategy.h" -#include "LocalizationStrategy.h" #include "PlatformStrategies.h" #include "PluginStrategy.h" #include "VisitedLinkStrategy.h" @@ -42,6 +41,7 @@ private: virtual WebCore::CookiesStrategy* createCookiesStrategy(); virtual WebCore::PluginStrategy* createPluginStrategy(); virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy(); + virtual WebCore::PasteboardStrategy* createPasteboardStrategy(); // WebCore::CookiesStrategy virtual void notifyCookiesChanged(); diff --git a/Source/WebKit/wx/ChangeLog b/Source/WebKit/wx/ChangeLog index b45b35005..0c6021eab 100644 --- a/Source/WebKit/wx/ChangeLog +++ b/Source/WebKit/wx/ChangeLog @@ -1,3 +1,47 @@ +2012-02-24 Shinya Kawanaka <shinyak@chromium.org> + + SpellCheckRequest needs to know the context where the spellcheck happened. + https://bugs.webkit.org/show_bug.cgi?id=79320 + + Reviewed by Hajime Morita. + + * WebKitSupport/EditorClientWx.h: + (WebCore::EditorClientWx::requestCheckingOfString): + +2012-02-21 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebKitSupport/EditorClientWx.cpp: + (WebCore::EditorClientWx::shouldApplyStyle): + * WebKitSupport/EditorClientWx.h: + (EditorClientWx): + +2012-02-22 Ryosuke Niwa <rniwa@webkit.org> + + Remove the remaining uses of CSSStyleDeclaration in Editor + https://bugs.webkit.org/show_bug.cgi?id=78939 + + Reviewed by Enrica Casucci. + + * WebKitSupport/EditorClientWx.cpp: + (WebCore::EditorClientWx::shouldApplyStyle): + * WebKitSupport/EditorClientWx.h: + (EditorClientWx): + +2012-02-15 Sadrul Habib Chowdhury <sadrul@chromium.org> + + Notify ChromeClient when touch-event handlers are installed/removed. + https://bugs.webkit.org/show_bug.cgi?id=77440 + + Reviewed by Darin Fisher and Ryosuke Niwa. + + * WebKitSupport/ChromeClientWx.h: + (WebCore::ChromeClientWx::numTouchEventHandlersChanged): + 2012-01-30 Kevin Ollivier <kevino@theolliviers.com> [wx] Unreviewed. Build fix, add JavaScriptCore/runtime diff --git a/Source/WebKit/wx/WebKitSupport/ChromeClientWx.h b/Source/WebKit/wx/WebKitSupport/ChromeClientWx.h index dcd164f34..2b6cdef61 100644 --- a/Source/WebKit/wx/WebKitSupport/ChromeClientWx.h +++ b/Source/WebKit/wx/WebKitSupport/ChromeClientWx.h @@ -151,6 +151,7 @@ public: virtual bool shouldRubberBandInDirection(WebCore::ScrollDirection) const { return true; } virtual void numWheelEventHandlersChanged(unsigned) { } + virtual void numTouchEventHandlersChanged(unsigned) { } virtual bool hasOpenedPopup() const; diff --git a/Source/WebKit/wx/WebKitSupport/EditorClientWx.cpp b/Source/WebKit/wx/WebKitSupport/EditorClientWx.cpp index 81d54f813..f2f9ca775 100644 --- a/Source/WebKit/wx/WebKitSupport/EditorClientWx.cpp +++ b/Source/WebKit/wx/WebKitSupport/EditorClientWx.cpp @@ -223,7 +223,7 @@ bool EditorClientWx::shouldInsertText(const String&, Range*, return true; } -bool EditorClientWx::shouldApplyStyle(CSSStyleDeclaration*, +bool EditorClientWx::shouldApplyStyle(StylePropertySet*, Range*) { notImplemented(); diff --git a/Source/WebKit/wx/WebKitSupport/EditorClientWx.h b/Source/WebKit/wx/WebKitSupport/EditorClientWx.h index d1403d17f..ece15fa87 100644 --- a/Source/WebKit/wx/WebKitSupport/EditorClientWx.h +++ b/Source/WebKit/wx/WebKitSupport/EditorClientWx.h @@ -64,7 +64,7 @@ public: EditorInsertAction); virtual bool shouldInsertText(const String&, Range*, EditorInsertAction); - virtual bool shouldApplyStyle(CSSStyleDeclaration*, + virtual bool shouldApplyStyle(StylePropertySet*, Range*); virtual bool shouldMoveRangeAfterDelete(Range*, Range*); virtual bool shouldChangeSelectedRange(Range* fromRange, Range* toRange, @@ -114,7 +114,7 @@ public: virtual void willSetInputMethodState(); virtual void setInputMethodState(bool enabled); - virtual void requestCheckingOfString(WebCore::SpellChecker*, int, WebCore::TextCheckingTypeMask, const WTF::String&) {} + virtual void requestCheckingOfString(WebCore::SpellChecker*, const WebCore::TextCheckingRequest&) { } virtual TextCheckerClient* textChecker() { return this; } private: |