diff -r 000000000000 -r 4f2f89ce4247 WebKitTools/DumpRenderTree/LayoutTestController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebKitTools/DumpRenderTree/LayoutTestController.h Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,344 @@ +/* + * Copyright (C) 2007, 2008, 2009 Apple 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. + */ + +#ifndef LayoutTestController_h +#define LayoutTestController_h + +#include +#include +#include +#include +#include +#include +#include + +class LayoutTestController : public RefCounted { +public: + static PassRefPtr create(const std::string& testPathOrURL, const std::string& expectedPixelHash); + ~LayoutTestController(); + + void makeWindowObject(JSContextRef context, JSObjectRef windowObject, JSValueRef* exception); + + void addDisallowedURL(JSStringRef url); + void clearAllDatabases(); + void clearBackForwardList(); + void clearPersistentUserStyleSheet(); + bool callShouldCloseOnWebView(); + JSStringRef copyDecodedHostName(JSStringRef name); + JSStringRef copyEncodedHostName(JSStringRef name); + void disableImageLoading(); + void dispatchPendingLoadRequests(); + void display(); + void execCommand(JSStringRef name, JSStringRef value); + JSRetainPtr counterValueForElementById(JSStringRef id); + bool isCommandEnabled(JSStringRef name); + void keepWebHistory(); + JSValueRef computedStyleIncludingVisitedInfo(JSContextRef, JSValueRef); + void notifyDone(); + int numberOfPages(float pageWidthInPixels, float pageHeightInPixels); + void overridePreference(JSStringRef key, JSStringRef value); + int pageNumberForElementById(JSStringRef id, float pageWidthInPixels, float pageHeightInPixels); + JSRetainPtr pageProperty(const char* propertyName, int pageNumber) const; + JSRetainPtr pageSizeAndMarginsInPixels(int pageNumber, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft) const; + bool isPageBoxVisible(int pageNumber) const; + JSStringRef pathToLocalResource(JSContextRef, JSStringRef url); + void queueBackNavigation(int howFarBackward); + void queueForwardNavigation(int howFarForward); + void queueLoad(JSStringRef url, JSStringRef target); + void queueLoadHTMLString(JSStringRef content, JSStringRef baseURL); + void queueLoadingScript(JSStringRef script); + void queueNonLoadingScript(JSStringRef script); + void queueReload(); + void removeAllVisitedLinks(); + void setAcceptsEditing(bool acceptsEditing); + void setAllowUniversalAccessFromFileURLs(bool); + void setAllowFileAccessFromFileURLs(bool); + void setAppCacheMaximumSize(unsigned long long quota); + void setAuthorAndUserStylesEnabled(bool); + void setCacheModel(int); + void setCustomPolicyDelegate(bool setDelegate, bool permissive); + void setDatabaseQuota(unsigned long long quota); + void setDomainRelaxationForbiddenForURLScheme(bool forbidden, JSStringRef scheme); + void setIconDatabaseEnabled(bool iconDatabaseEnabled); + void setJavaScriptProfilingEnabled(bool profilingEnabled); + void setJavaScriptCanAccessClipboard(bool flag); + void setMainFrameIsFirstResponder(bool flag); + void setMockGeolocationError(int code, JSStringRef message); + void setMockGeolocationPosition(double latitude, double longitude, double accuracy); + void setPersistentUserStyleSheetLocation(JSStringRef path); + void setPluginsEnabled(bool flag); + void setPopupBlockingEnabled(bool flag); + void setPrivateBrowsingEnabled(bool flag); + void setSelectTrailingWhitespaceEnabled(bool flag); + void setSmartInsertDeleteEnabled(bool flag); + void setTabKeyCyclesThroughElements(bool cycles); + void setUseDashboardCompatibilityMode(bool flag); + void setUserStyleSheetEnabled(bool flag); + void setUserStyleSheetLocation(JSStringRef path); + void setXSSAuditorEnabled(bool flag); + void setFrameFlatteningEnabled(bool enable); + void setSpatialNavigationEnabled(bool enable); + void setScrollbarPolicy(JSStringRef orientation, JSStringRef policy); + void setEditingBehavior(const char* editingBehavior); + + void waitForPolicyDelegate(); + size_t webHistoryItemCount(); + unsigned workerThreadCount() const; + int windowCount(); + + void grantDesktopNotificationPermission(JSStringRef origin); + bool checkDesktopNotificationPermission(JSStringRef origin); + + bool elementDoesAutoCompleteForElementWithId(JSStringRef id); + + bool dumpAsPDF() const { return m_dumpAsPDF; } + void setDumpAsPDF(bool dumpAsPDF) { m_dumpAsPDF = dumpAsPDF; } + + bool dumpAsText() const { return m_dumpAsText; } + void setDumpAsText(bool dumpAsText) { m_dumpAsText = dumpAsText; } + + bool generatePixelResults() const { return m_generatePixelResults; } + void setGeneratePixelResults(bool generatePixelResults) { m_generatePixelResults = generatePixelResults; } + + bool dumpBackForwardList() const { return m_dumpBackForwardList; } + void setDumpBackForwardList(bool dumpBackForwardList) { m_dumpBackForwardList = dumpBackForwardList; } + + bool dumpChildFrameScrollPositions() const { return m_dumpChildFrameScrollPositions; } + void setDumpChildFrameScrollPositions(bool dumpChildFrameScrollPositions) { m_dumpChildFrameScrollPositions = dumpChildFrameScrollPositions; } + + bool dumpChildFramesAsText() const { return m_dumpChildFramesAsText; } + void setDumpChildFramesAsText(bool dumpChildFramesAsText) { m_dumpChildFramesAsText = dumpChildFramesAsText; } + + bool dumpDatabaseCallbacks() const { return m_dumpDatabaseCallbacks; } + void setDumpDatabaseCallbacks(bool dumpDatabaseCallbacks) { m_dumpDatabaseCallbacks = dumpDatabaseCallbacks; } + + bool dumpDOMAsWebArchive() const { return m_dumpDOMAsWebArchive; } + void setDumpDOMAsWebArchive(bool dumpDOMAsWebArchive) { m_dumpDOMAsWebArchive = dumpDOMAsWebArchive; } + + bool dumpEditingCallbacks() const { return m_dumpEditingCallbacks; } + void setDumpEditingCallbacks(bool dumpEditingCallbacks) { m_dumpEditingCallbacks = dumpEditingCallbacks; } + + bool dumpFrameLoadCallbacks() const { return m_dumpFrameLoadCallbacks; } + void setDumpFrameLoadCallbacks(bool dumpFrameLoadCallbacks) { m_dumpFrameLoadCallbacks = dumpFrameLoadCallbacks; } + + bool dumpHistoryDelegateCallbacks() const { return m_dumpHistoryDelegateCallbacks; } + void setDumpHistoryDelegateCallbacks(bool dumpHistoryDelegateCallbacks) { m_dumpHistoryDelegateCallbacks = dumpHistoryDelegateCallbacks; } + + bool dumpResourceLoadCallbacks() const { return m_dumpResourceLoadCallbacks; } + void setDumpResourceLoadCallbacks(bool dumpResourceLoadCallbacks) { m_dumpResourceLoadCallbacks = dumpResourceLoadCallbacks; } + + bool dumpResourceResponseMIMETypes() const { return m_dumpResourceResponseMIMETypes; } + void setDumpResourceResponseMIMETypes(bool dumpResourceResponseMIMETypes) { m_dumpResourceResponseMIMETypes = dumpResourceResponseMIMETypes; } + + bool dumpSelectionRect() const { return m_dumpSelectionRect; } + void setDumpSelectionRect(bool dumpSelectionRect) { m_dumpSelectionRect = dumpSelectionRect; } + + bool dumpSourceAsWebArchive() const { return m_dumpSourceAsWebArchive; } + void setDumpSourceAsWebArchive(bool dumpSourceAsWebArchive) { m_dumpSourceAsWebArchive = dumpSourceAsWebArchive; } + + bool dumpStatusCallbacks() const { return m_dumpStatusCallbacks; } + void setDumpStatusCallbacks(bool dumpStatusCallbacks) { m_dumpStatusCallbacks = dumpStatusCallbacks; } + + bool dumpTitleChanges() const { return m_dumpTitleChanges; } + void setDumpTitleChanges(bool dumpTitleChanges) { m_dumpTitleChanges = dumpTitleChanges; } + + bool dumpIconChanges() const { return m_dumpIconChanges; } + void setDumpIconChanges(bool dumpIconChanges) { m_dumpIconChanges = dumpIconChanges; } + + bool dumpVisitedLinksCallback() const { return m_dumpVisitedLinksCallback; } + void setDumpVisitedLinksCallback(bool dumpVisitedLinksCallback) { m_dumpVisitedLinksCallback = dumpVisitedLinksCallback; } + + bool dumpWillCacheResponse() const { return m_dumpWillCacheResponse; } + void setDumpWillCacheResponse(bool dumpWillCacheResponse) { m_dumpWillCacheResponse = dumpWillCacheResponse; } + + bool callCloseOnWebViews() const { return m_callCloseOnWebViews; } + void setCallCloseOnWebViews(bool callCloseOnWebViews) { m_callCloseOnWebViews = callCloseOnWebViews; } + + bool canOpenWindows() const { return m_canOpenWindows; } + void setCanOpenWindows(bool canOpenWindows) { m_canOpenWindows = canOpenWindows; } + + bool closeRemainingWindowsWhenComplete() const { return m_closeRemainingWindowsWhenComplete; } + void setCloseRemainingWindowsWhenComplete(bool closeRemainingWindowsWhenComplete) { m_closeRemainingWindowsWhenComplete = closeRemainingWindowsWhenComplete; } + + bool newWindowsCopyBackForwardList() const { return m_newWindowsCopyBackForwardList; } + void setNewWindowsCopyBackForwardList(bool newWindowsCopyBackForwardList) { m_newWindowsCopyBackForwardList = newWindowsCopyBackForwardList; } + + bool stopProvisionalFrameLoads() const { return m_stopProvisionalFrameLoads; } + void setStopProvisionalFrameLoads(bool stopProvisionalFrameLoads) { m_stopProvisionalFrameLoads = stopProvisionalFrameLoads; } + + bool testOnscreen() const { return m_testOnscreen; } + void setTestOnscreen(bool testOnscreen) { m_testOnscreen = testOnscreen; } + + bool testRepaint() const { return m_testRepaint; } + void setTestRepaint(bool testRepaint) { m_testRepaint = testRepaint; } + + bool testRepaintSweepHorizontally() const { return m_testRepaintSweepHorizontally; } + void setTestRepaintSweepHorizontally(bool testRepaintSweepHorizontally) { m_testRepaintSweepHorizontally = testRepaintSweepHorizontally; } + + bool waitToDump() const { return m_waitToDump; } + void setWaitToDump(bool waitToDump); + void waitToDumpWatchdogTimerFired(); + + const std::set& willSendRequestClearHeaders() const { return m_willSendRequestClearHeaders; } + void setWillSendRequestClearHeader(std::string header) { m_willSendRequestClearHeaders.insert(header); } + + bool willSendRequestReturnsNull() const { return m_willSendRequestReturnsNull; } + void setWillSendRequestReturnsNull(bool returnsNull) { m_willSendRequestReturnsNull = returnsNull; } + + bool willSendRequestReturnsNullOnRedirect() const { return m_willSendRequestReturnsNullOnRedirect; } + void setWillSendRequestReturnsNullOnRedirect(bool returnsNull) { m_willSendRequestReturnsNullOnRedirect = returnsNull; } + + bool windowIsKey() const { return m_windowIsKey; } + void setWindowIsKey(bool windowIsKey); + + bool alwaysAcceptCookies() const { return m_alwaysAcceptCookies; } + void setAlwaysAcceptCookies(bool alwaysAcceptCookies); + + bool handlesAuthenticationChallenges() const { return m_handlesAuthenticationChallenges; } + void setHandlesAuthenticationChallenges(bool handlesAuthenticationChallenges) { m_handlesAuthenticationChallenges = handlesAuthenticationChallenges; } + + bool isPrinting() const { return m_isPrinting; } + void setIsPrinting(bool isPrinting) { m_isPrinting = isPrinting; } + + const std::string& authenticationUsername() const { return m_authenticationUsername; } + void setAuthenticationUsername(std::string username) { m_authenticationUsername = username; } + + const std::string& authenticationPassword() const { return m_authenticationPassword; } + void setAuthenticationPassword(std::string password) { m_authenticationPassword = password; } + + bool globalFlag() const { return m_globalFlag; } + void setGlobalFlag(bool globalFlag) { m_globalFlag = globalFlag; } + + bool deferMainResourceDataLoad() const { return m_deferMainResourceDataLoad; } + void setDeferMainResourceDataLoad(bool flag) { m_deferMainResourceDataLoad = flag; } + + const std::string& testPathOrURL() const { return m_testPathOrURL; } + const std::string& expectedPixelHash() const { return m_expectedPixelHash; } + + bool pauseAnimationAtTimeOnElementWithId(JSStringRef animationName, double time, JSStringRef elementId); + bool pauseTransitionAtTimeOnElementWithId(JSStringRef propertyName, double time, JSStringRef elementId); + bool sampleSVGAnimationForElementAtTime(JSStringRef animationId, double time, JSStringRef elementId); + unsigned numberOfActiveAnimations() const; + + void addOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef destinationProtocol, JSStringRef destinationHost, bool allowDestinationSubdomains); + void removeOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef destinationProtocol, JSStringRef destinationHost, bool allowDestinationSubdomains); + + void addUserScript(JSStringRef source, bool runAtStart, bool allFrames); + void addUserStyleSheet(JSStringRef source, bool allFrames); + + void setGeolocationPermission(bool allow); + bool isGeolocationPermissionSet() const { return m_isGeolocationPermissionSet; } + bool geolocationPermission() const { return m_geolocationPermission; } + + void setDeveloperExtrasEnabled(bool); + void showWebInspector(); + void closeWebInspector(); + void setTimelineProfilingEnabled(bool enabled); + void evaluateInWebInspector(long callId, JSStringRef script); + void evaluateScriptInIsolatedWorld(unsigned worldId, JSObjectRef globalObject, JSStringRef script); + + void setPOSIXLocale(JSStringRef locale); + + void setWebViewEditable(bool); + + void abortModal(); + + // The following API test functions should probably be moved to platform-specific + // unit tests outside of DRT once they exist. + void apiTestNewWindowDataLoadBaseURL(JSStringRef utf8Data, JSStringRef baseURL); + void apiTestGoToCurrentBackForwardItem(); + + // Simulate a request an embedding application could make, populating per-session credential storage. + void authenticateSession(JSStringRef url, JSStringRef username, JSStringRef password); + + JSRetainPtr layerTreeAsText() const; + + JSRetainPtr markerTextForListItem(JSContextRef context, JSValueRef nodeObject) const; + + static const unsigned maxViewWidth; + static const unsigned maxViewHeight; + +private: + LayoutTestController(const std::string& testPathOrURL, const std::string& expectedPixelHash); + + bool m_dumpAsPDF; + bool m_dumpAsText; + bool m_dumpBackForwardList; + bool m_dumpChildFrameScrollPositions; + bool m_dumpChildFramesAsText; + bool m_dumpDOMAsWebArchive; + bool m_dumpDatabaseCallbacks; + bool m_dumpEditingCallbacks; + bool m_dumpFrameLoadCallbacks; + bool m_dumpHistoryDelegateCallbacks; + bool m_dumpResourceLoadCallbacks; + bool m_dumpResourceResponseMIMETypes; + bool m_dumpSelectionRect; + bool m_dumpSourceAsWebArchive; + bool m_dumpStatusCallbacks; + bool m_dumpTitleChanges; + bool m_dumpIconChanges; + bool m_dumpVisitedLinksCallback; + bool m_dumpWillCacheResponse; + bool m_generatePixelResults; + bool m_callCloseOnWebViews; + bool m_canOpenWindows; + bool m_closeRemainingWindowsWhenComplete; + bool m_newWindowsCopyBackForwardList; + bool m_stopProvisionalFrameLoads; + bool m_testOnscreen; + bool m_testRepaint; + bool m_testRepaintSweepHorizontally; + bool m_waitToDump; // True if waitUntilDone() has been called, but notifyDone() has not yet been called. + bool m_willSendRequestReturnsNull; + bool m_willSendRequestReturnsNullOnRedirect; + bool m_windowIsKey; + bool m_alwaysAcceptCookies; + bool m_globalFlag; + bool m_isGeolocationPermissionSet; + bool m_geolocationPermission; + bool m_handlesAuthenticationChallenges; + bool m_isPrinting; + bool m_deferMainResourceDataLoad; + + std::string m_authenticationUsername; + std::string m_authenticationPassword; + std::string m_testPathOrURL; + std::string m_expectedPixelHash; // empty string if no hash + + std::set m_willSendRequestClearHeaders; + + // origins which have been granted desktop notification access + std::vector m_desktopNotificationAllowedOrigins; + + static JSClassRef getJSClass(); + static JSStaticValue* staticValues(); + static JSStaticFunction* staticFunctions(); +}; + +#endif // LayoutTestController_h