[Chromium] Introduce TestInterfaces to hold all the JavaScript interfaces needed...
[WebKit-https.git] / Tools / DumpRenderTree / chromium / TestShell.h
1 /*
2  * Copyright (C) 2012 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef TestShell_h
32 #define TestShell_h
33
34 #include "AccessibilityController.h"
35 #include "EventSender.h"
36 #include "GamepadController.h"
37 #include "LayoutTestController.h"
38 #include "NotificationPresenter.h"
39 #include "TestEventPrinter.h"
40 #include "TestInterfaces.h"
41 #include "TextInputController.h"
42 #include "WebPreferences.h"
43 #include "WebViewHost.h"
44 #include <string>
45 #include <wtf/OwnPtr.h>
46 #include <wtf/Vector.h>
47
48 // TestShell is a container of global variables and has bridge functions between
49 // various objects. Only one instance is created in one DRT process.
50
51 namespace WebKit {
52 class WebDevToolsAgentClient;
53 class WebFrame;
54 class WebNotificationPresenter;
55 class WebThread;
56 class WebView;
57 class WebURL;
58 }
59
60 class DRTDevToolsAgent;
61 class DRTDevToolsCallArgs;
62 class DRTDevToolsClient;
63 class MockWebPrerenderingSupport;
64 class WebPermissions;
65
66 struct TestParams {
67     bool dumpTree;
68     bool dumpPixels;
69     bool debugRenderTree;
70     bool debugLayerTree;
71     bool printSeparators;
72     WebKit::WebURL testUrl;
73     // Resultant image file name. Required only if the test_shell mode.
74     std::string pixelFileName;
75     std::string pixelHash;
76
77     TestParams()
78         : dumpTree(true)
79         , dumpPixels(false)
80         , debugRenderTree(false)
81         , debugLayerTree(false)
82         , printSeparators(false) { }
83 };
84
85 class TestShell {
86 public:
87     TestShell();
88     ~TestShell();
89
90     void initialize();
91
92     // The main WebView.
93     WebKit::WebView* webView() const { return m_webView; }
94     // Returns the host for the main WebView.
95     WebViewHost* webViewHost() const { return m_webViewHost.get(); }
96     LayoutTestController* layoutTestController() const { return m_layoutTestController.get(); }
97     EventSender* eventSender() const { return m_eventSender.get(); }
98     AccessibilityController* accessibilityController() const { return m_accessibilityController.get(); }
99 #if ENABLE(NOTIFICATIONS)
100     NotificationPresenter* notificationPresenter() const { return m_notificationPresenter.get(); }
101 #endif
102     TestEventPrinter* printer() const { return m_printer.get(); }
103
104     WebPreferences* preferences() { return &m_prefs; }
105     void applyPreferences() { m_prefs.applyTo(m_webView); }
106
107     WebPermissions* webPermissions() { return m_webPermissions.get(); }
108
109     void bindJSObjectsToWindow(WebKit::WebFrame*);
110     void runFileTest(const TestParams&);
111     void callJSGC();
112     void resetTestController();
113     void waitTestFinished();
114
115     // Operations to the main window.
116     void loadURL(const WebKit::WebURL&);
117     void reload();
118     void goToOffset(int offset);
119     int navigationEntryCount() const;
120
121     void setFocus(WebKit::WebWidget*, bool enable);
122     bool shouldDumpFrameLoadCallbacks() const { return (m_testIsPreparing || m_testIsPending) && layoutTestController()->shouldDumpFrameLoadCallbacks(); }
123     bool shouldDumpUserGestureInFrameLoadCallbacks() const { return (m_testIsPreparing || m_testIsPending) && layoutTestController()->shouldDumpUserGestureInFrameLoadCallbacks(); }
124     bool shouldDumpResourceLoadCallbacks() const  { return (m_testIsPreparing || m_testIsPending) && layoutTestController()->shouldDumpResourceLoadCallbacks(); }
125     bool shouldDumpResourceResponseMIMETypes() const  { return (m_testIsPreparing || m_testIsPending) && layoutTestController()->shouldDumpResourceResponseMIMETypes(); }
126     void setIsLoading(bool flag) { m_isLoading = flag; }
127
128     // Called by the LayoutTestController to signal test completion.
129     void testFinished();
130     // Called by LayoutTestController when a test hits the timeout, but does not
131     // cause a hang. We can avoid killing TestShell in this case and still dump
132     // the test results.
133     void testTimedOut();
134
135     bool allowExternalPages() const { return m_allowExternalPages; }
136     void setAllowExternalPages(bool allowExternalPages) { m_allowExternalPages = allowExternalPages; }
137
138     void setTestShellMode(bool testShellMode) { m_testShellMode = testShellMode; }
139     void setAcceleratedCompositingForVideoEnabled(bool enabled) { m_acceleratedCompositingForVideoEnabled = enabled; }
140     void setThreadedCompositingEnabled(bool enabled) { m_threadedCompositingEnabled = enabled; }
141     void setForceCompositingMode(bool enabled) { m_forceCompositingMode = enabled; }
142     void setAccelerated2dCanvasEnabled(bool enabled) { m_accelerated2dCanvasEnabled = enabled; }
143     void setDeferred2dCanvasEnabled(bool enabled) { m_deferred2dCanvasEnabled = enabled; }
144     void setAcceleratedPaintingEnabled(bool enabled) { m_acceleratedPaintingEnabled = enabled; }
145     void setPerTilePaintingEnabled(bool);
146 #if defined(OS_WIN)
147     // Access to the finished event. Used by the static WatchDog thread.
148     HANDLE finishedEvent() { return m_finishedEvent; }
149 #endif
150
151     // Get the timeout for running a test in milliseconds.
152     int layoutTestTimeout() { return m_timeout; }
153     int layoutTestTimeoutForWatchDog() { return layoutTestTimeout() + 1000; }
154     void setLayoutTestTimeout(int timeout) { m_timeout = timeout; }
155
156     // V8 JavaScript stress test options.
157     int stressOpt() { return m_stressOpt; }
158     void setStressOpt(bool stressOpt) { m_stressOpt = stressOpt; }
159     int stressDeopt() { return m_stressDeopt; }
160     void setStressDeopt(int stressDeopt) { m_stressDeopt = stressDeopt; }
161
162     // The JavaScript flags specified as a strings.
163     std::string javaScriptFlags() { return m_javaScriptFlags; }
164     void setJavaScriptFlags(std::string javaScriptFlags) { m_javaScriptFlags = javaScriptFlags; }
165
166     // Set whether to dump when the loaded page has finished processing. This is used with multiple load
167     // testing where we only want to have the output from the last load.
168     void setDumpWhenFinished(bool dumpWhenFinished) { m_dumpWhenFinished = dumpWhenFinished; }
169
170     void setIsDisplayingModalDialog(bool isDisplayingModalDialog) { m_isDisplayingModalDialog = isDisplayingModalDialog; }
171     bool isDisplayingModalDialog() const { return m_isDisplayingModalDialog; }
172
173     WebViewHost* createNewWindow(const WebKit::WebURL&);
174     void closeWindow(WebViewHost*);
175     void closeRemainingWindows();
176     int windowCount();
177     static void resizeWindowForTest(WebViewHost*, const WebKit::WebURL&);
178
179     void showDevTools();
180     void closeDevTools();
181
182     DRTDevToolsAgent* drtDevToolsAgent() { return m_drtDevToolsAgent.get(); }
183     DRTDevToolsClient* drtDevToolsClient() { return m_drtDevToolsClient.get(); }
184     WebViewHost* devToolsWebView() { return m_devTools; }
185
186     static const int virtualWindowBorder = 3;
187
188     typedef Vector<WebViewHost*> WindowList;
189     WindowList windowList() const { return m_windowList; }
190
191     // Returns a string representation of an URL's spec that does not depend on
192     // the location of the layout test in the file system.
193     std::string normalizeLayoutTestURL(const std::string&);
194
195 private:
196     WebViewHost* createNewWindow(const WebKit::WebURL&, DRTDevToolsAgent*);
197     void createMainWindow();
198     void createDRTDevToolsClient(DRTDevToolsAgent*);
199
200     void resetWebSettings(WebKit::WebView&);
201     void dump();
202     std::string dumpAllBackForwardLists();
203     void dumpImage(SkCanvas*) const;
204
205     bool m_testIsPending;
206     bool m_testIsPreparing;
207     bool m_isLoading;
208     WebKit::WebView* m_webView;
209     WebKit::WebWidget* m_focusedWidget;
210     bool m_testShellMode;
211     WebViewHost* m_devTools;
212
213     // Be careful of the destruction order of the following objects.
214     OwnPtr<TestEventPrinter> m_printer;
215     OwnPtr<WebPermissions> m_webPermissions;
216     OwnPtr<DRTDevToolsAgent> m_drtDevToolsAgent;
217     OwnPtr<DRTDevToolsClient> m_drtDevToolsClient;
218     OwnPtr<AccessibilityController> m_accessibilityController;
219     OwnPtr<TestInterfaces> m_testInterfaces;
220     OwnPtr<EventSender> m_eventSender;
221     OwnPtr<LayoutTestController> m_layoutTestController;
222     OwnPtr<TextInputController> m_textInputController;
223 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
224     OwnPtr<NotificationPresenter> m_notificationPresenter;
225 #endif
226     OwnPtr<WebViewHost> m_webViewHost;
227     OwnPtr<WebKit::WebThread> m_webCompositorThread;
228 #if ENABLE(LINK_PRERENDER)
229     OwnPtr<MockWebPrerenderingSupport> m_prerenderingSupport;
230 #endif
231
232     TestParams m_params;
233     int m_timeout; // timeout value in millisecond
234     bool m_allowExternalPages;
235     bool m_acceleratedCompositingForVideoEnabled;
236     bool m_threadedCompositingEnabled;
237     bool m_forceCompositingMode;
238     bool m_accelerated2dCanvasEnabled;
239     bool m_deferred2dCanvasEnabled;
240     bool m_acceleratedPaintingEnabled;
241     bool m_perTilePaintingEnabled;
242     WebPreferences m_prefs;
243     bool m_stressOpt;
244     bool m_stressDeopt;
245     std::string m_javaScriptFlags;
246     bool m_dumpWhenFinished;
247     bool m_isDisplayingModalDialog;
248
249
250     // List of all windows in this process.
251     // The main window should be put into windowList[0].
252     WindowList m_windowList;
253
254 #if defined(OS_WIN)
255     // Used by the watchdog to know when it's finished.
256     HANDLE m_finishedEvent;
257 #endif
258 };
259
260 void platformInit(int*, char***);
261 void openStartupDialog();
262 bool checkLayoutTestSystemDependencies();
263
264 #endif // TestShell_h