24e8d62c35b385408ac275a37dd57373f8d7a7cb
[WebKit-https.git] / WebKitTools / DumpRenderTree / gtk / DumpRenderTree.cpp
1 /*
2  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  * Copyright (C) 2008 Alp Toker <alp@nuanti.com>
4  * Copyright (C) 2009 Jan Alonzo <jmalonzo@gmail.com>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1.  Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer.
12  * 2.  Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution.
15  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
16  *     its contributors may be used to endorse or promote products derived
17  *     from this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "DumpRenderTree.h"
33
34 #include "LayoutTestController.h"
35 #include "WorkQueue.h"
36 #include "WorkQueueItem.h"
37
38 #include <gtk/gtk.h>
39 #include <webkit/webkit.h>
40 #include <JavaScriptCore/JavaScript.h>
41
42 #include <wtf/Assertions.h>
43
44 #include <cassert>
45 #include <getopt.h>
46 #include <stdlib.h>
47 #include <string.h>
48
49 using namespace std;
50
51 extern "C" {
52 // This API is not yet public.
53 extern G_CONST_RETURN gchar* webkit_web_history_item_get_target(WebKitWebHistoryItem*);
54 extern gboolean webkit_web_history_item_is_target_item(WebKitWebHistoryItem*);
55 extern GList* webkit_web_history_item_get_children(WebKitWebHistoryItem*);
56 extern GSList* webkit_web_frame_get_children(WebKitWebFrame* frame);
57 extern gchar* webkit_web_frame_get_inner_text(WebKitWebFrame* frame);
58 extern gchar* webkit_web_frame_dump_render_tree(WebKitWebFrame* frame);
59 extern void webkit_web_settings_add_extra_plugin_directory(WebKitWebView* view, const gchar* directory);
60 extern gchar* webkit_web_frame_get_response_mime_type(WebKitWebFrame* frame);
61 }
62
63 volatile bool done;
64 static bool printSeparators;
65 static int dumpPixels;
66 static int dumpTree = 1;
67
68 LayoutTestController* gLayoutTestController = 0;
69 static WebKitWebView* webView;
70 WebKitWebFrame* mainFrame = 0;
71 WebKitWebFrame* topLoadingFrame = 0;
72 guint waitToDumpWatchdog = 0;
73
74 // current b/f item at the end of the previous test
75 static WebKitWebHistoryItem* prevTestBFItem = NULL;
76
77 const unsigned maxViewHeight = 600;
78 const unsigned maxViewWidth = 800;
79 const unsigned historyItemIndent = 8;
80
81 static gchar* autocorrectURL(const gchar* url)
82 {
83     if (strncmp("http://", url, 7) != 0 && strncmp("https://", url, 8) != 0) {
84         GString* string = g_string_new("file://");
85         g_string_append(string, url);
86         return g_string_free(string, FALSE);
87     }
88
89     return g_strdup(url);
90 }
91
92 static bool shouldLogFrameLoadDelegates(const char* pathOrURL)
93 {
94     return strstr(pathOrURL, "loading/");
95 }
96
97 void dumpFrameScrollPosition(WebKitWebFrame* frame)
98 {
99
100 }
101
102 void displayWebView()
103 {
104
105 }
106
107 static void appendString(gchar*& target, gchar* string)
108 {
109     gchar* oldString = target;
110     target = g_strconcat(target, string, NULL);
111     g_free(oldString);
112 }
113
114 static gchar* dumpFramesAsText(WebKitWebFrame* frame)
115 {
116     gchar* result = 0;
117
118     // Add header for all but the main frame.
119     bool isMainFrame = (webkit_web_view_get_main_frame(webView) == frame);
120
121     gchar* innerText = webkit_web_frame_get_inner_text(frame);
122     if (isMainFrame)
123         result = g_strdup_printf("%s\n", innerText);
124     else {
125         const gchar* frameName = webkit_web_frame_get_name(frame);
126         result = g_strdup_printf("\n--------\nFrame: '%s'\n--------\n%s\n", frameName, innerText);
127     }
128     g_free(innerText);
129
130     if (gLayoutTestController->dumpChildFramesAsText()) {
131         GSList* children = webkit_web_frame_get_children(frame);
132         for (GSList* child = children; child; child = g_slist_next(child))
133            appendString(result, dumpFramesAsText((WebKitWebFrame*)children->data));
134         g_slist_free(children);
135     }
136
137     return result;
138 }
139
140 static gint compareHistoryItems(gpointer* item1, gpointer* item2)
141 {
142     return g_ascii_strcasecmp(webkit_web_history_item_get_target(WEBKIT_WEB_HISTORY_ITEM(item1)),
143                               webkit_web_history_item_get_target(WEBKIT_WEB_HISTORY_ITEM(item2)));
144 }
145
146 static void dumpHistoryItem(WebKitWebHistoryItem* item, int indent, bool current)
147 {
148     ASSERT(item != NULL);
149     int start = 0;
150     g_object_ref(item);
151     if (current) {
152         printf("curr->");
153         start = 6;
154     }
155     for (int i = start; i < indent; i++)
156         putchar(' ');
157     printf("%s", webkit_web_history_item_get_uri(item));
158     const gchar* target = webkit_web_history_item_get_target(item);
159     if (target && g_utf8_strlen(target, 0) > 0)
160         printf(" (in frame \"%s\")", target);
161     if (webkit_web_history_item_is_target_item(item))
162         printf("  **nav target**");
163     putchar('\n');
164     GList* kids = webkit_web_history_item_get_children(item);
165     if (kids) {
166         // must sort to eliminate arbitrary result ordering which defeats reproducible testing
167         kids = g_list_sort(kids, (GCompareFunc) compareHistoryItems);
168         for (unsigned i = 0; i < g_list_length(kids); i++)
169             dumpHistoryItem(WEBKIT_WEB_HISTORY_ITEM(g_list_nth_data(kids, i)), indent+4, FALSE);
170     }
171     g_object_unref(item);
172 }
173
174 static void dumpBackForwardListForWebView(WebKitWebView* view)
175 {
176     printf("\n============== Back Forward List ==============\n");
177     WebKitWebBackForwardList* bfList = webkit_web_view_get_back_forward_list(view);
178
179     // Print out all items in the list after prevTestBFItem, which was from the previous test
180     // Gather items from the end of the list, the print them out from oldest to newest
181     GList* itemsToPrint = NULL;
182     gint forwardListCount = webkit_web_back_forward_list_get_forward_length(bfList);
183     for (int i = forwardListCount; i > 0; i--) {
184         WebKitWebHistoryItem* item = webkit_web_back_forward_list_get_nth_item(bfList, i);
185         // something is wrong if the item from the last test is in the forward part of the b/f list
186         ASSERT(item != prevTestBFItem);
187         g_object_ref(item);
188         itemsToPrint = g_list_append(itemsToPrint, item);
189     }
190
191     WebKitWebHistoryItem* currentItem = webkit_web_back_forward_list_get_current_item(bfList);
192
193     g_object_ref(currentItem);
194     itemsToPrint = g_list_append(itemsToPrint, currentItem);
195
196     gint currentItemIndex = g_list_length(itemsToPrint) - 1;
197     gint backListCount = webkit_web_back_forward_list_get_back_length(bfList);
198     for (int i = -1; i >= -(backListCount); i--) {
199         WebKitWebHistoryItem* item = webkit_web_back_forward_list_get_nth_item(bfList, i);
200         if (item == prevTestBFItem)
201             break;
202         g_object_ref(item);
203         itemsToPrint = g_list_append(itemsToPrint, item);
204     }
205
206     for (int i = g_list_length(itemsToPrint) - 1; i >= 0; i--) {
207         WebKitWebHistoryItem* item = WEBKIT_WEB_HISTORY_ITEM(g_list_nth_data(itemsToPrint, i));
208         dumpHistoryItem(item, historyItemIndent, i == currentItemIndex);
209         g_object_unref(item);
210     }
211     g_list_free(itemsToPrint);
212     printf("===============================================\n");
213 }
214
215 static void invalidateAnyPreviousWaitToDumpWatchdog()
216 {
217     if (waitToDumpWatchdog) {
218         g_source_remove(waitToDumpWatchdog);
219         waitToDumpWatchdog = 0;
220     }
221 }
222
223 static void resetWebViewToConsistentStateBeforeTesting()
224 {
225     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);
226     g_object_set(G_OBJECT(settings),
227                  "enable-private-browsing", FALSE,
228                  "enable-developer-extras", FALSE,
229                  NULL);
230
231     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
232     g_object_set(G_OBJECT(inspector), "javascript-profiling-enabled", FALSE, NULL);
233 }
234
235 void dump()
236 {
237     invalidateAnyPreviousWaitToDumpWatchdog();
238
239     bool dumpAsText = gLayoutTestController->dumpAsText();
240     if (dumpTree) {
241         char* result = 0;
242         gchar* responseMimeType = webkit_web_frame_get_response_mime_type(mainFrame);
243
244         dumpAsText = g_ascii_strcasecmp(responseMimeType, "text/plain");
245         g_free(responseMimeType);
246
247         gLayoutTestController->setDumpAsText(dumpAsText);
248         if (gLayoutTestController->dumpAsText())
249             result = dumpFramesAsText(mainFrame);
250         else
251             result = webkit_web_frame_dump_render_tree(mainFrame);
252
253         if (!result) {
254             const char* errorMessage;
255             if (gLayoutTestController->dumpAsText())
256                 errorMessage = "[documentElement innerText]";
257             else if (gLayoutTestController->dumpDOMAsWebArchive())
258                 errorMessage = "[[mainFrame DOMDocument] webArchive]";
259             else if (gLayoutTestController->dumpSourceAsWebArchive())
260                 errorMessage = "[[mainFrame dataSource] webArchive]";
261             else
262                 errorMessage = "[mainFrame renderTreeAsExternalRepresentation]";
263             printf("ERROR: nil result from %s", errorMessage);
264         } else {
265             printf("%s", result);
266             g_free(result);
267             if (!gLayoutTestController->dumpAsText() && !gLayoutTestController->dumpDOMAsWebArchive() && !gLayoutTestController->dumpSourceAsWebArchive())
268                 dumpFrameScrollPosition(mainFrame);
269
270             if (gLayoutTestController->dumpBackForwardList()) {
271                 // FIXME: multiple windows support
272                 dumpBackForwardListForWebView(webView);
273
274             }
275         }
276
277         if (printSeparators) {
278             puts("#EOF"); // terminate the content block
279             fputs("#EOF\n", stderr);
280             fflush(stdout);
281             fflush(stderr);
282         }
283     }
284
285     if (dumpPixels) {
286         if (!gLayoutTestController->dumpAsText() && !gLayoutTestController->dumpDOMAsWebArchive() && !gLayoutTestController->dumpSourceAsWebArchive()) {
287             // FIXME: Add support for dumping pixels
288         }
289     }
290
291     // FIXME: call displayWebView here when we support --paint
292
293     puts("#EOF"); // terminate the (possibly empty) pixels block
294
295     fflush(stdout);
296     fflush(stderr);
297
298     done = true;
299 }
300
301 static void setDefaultsToConsistentStateValuesForTesting()
302 {
303     gdk_screen_set_resolution(gdk_screen_get_default(), 72.0);
304
305     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);
306     g_object_set(G_OBJECT(settings),
307                  "default-font-family", "Times",
308                  "monospace-font-family", "Courier",
309                  "serif-font-family", "Times",
310                  "sans-serif-font-family", "Helvetica",
311                  "default-font-size", 16,
312                  "default-monospace-font-size", 13,
313                  "minimum-font-size", 1,
314                  NULL);
315
316     /* Disable the default auth dialog for testing */
317     SoupSession* session = webkit_get_default_session();
318     soup_session_remove_feature_by_type(session, WEBKIT_TYPE_SOUP_AUTH_DIALOG);
319
320 #if PLATFORM(X11)
321     webkit_web_settings_add_extra_plugin_directory(webView, TEST_PLUGIN_DIR);
322 #endif
323 }
324
325 static void runTest(const string& testPathOrURL)
326 {
327     ASSERT(!testPathOrURL.empty());
328
329     // Look for "'" as a separator between the path or URL, and the pixel dump hash that follows.
330     string pathOrURL(testPathOrURL);
331     string expectedPixelHash;
332
333     size_t separatorPos = pathOrURL.find("'");
334     if (separatorPos != string::npos) {
335         pathOrURL = string(testPathOrURL, 0, separatorPos);
336         expectedPixelHash = string(testPathOrURL, separatorPos + 1);
337     }
338
339     gchar* url = autocorrectURL(pathOrURL.c_str());
340     const string testURL(url);
341
342     resetWebViewToConsistentStateBeforeTesting();
343
344     gLayoutTestController = new LayoutTestController(testURL, expectedPixelHash);
345     topLoadingFrame = 0;
346     done = false;
347
348     gLayoutTestController->setIconDatabaseEnabled(false);
349
350     if (shouldLogFrameLoadDelegates(pathOrURL.c_str()))
351         gLayoutTestController->setDumpFrameLoadCallbacks(true);
352
353     WorkQueue::shared()->clear();
354     WorkQueue::shared()->setFrozen(false);
355
356     bool isSVGW3CTest = (gLayoutTestController->testPathOrURL().find("svg/W3C-SVG-1.1") != string::npos);
357     GtkAllocation size;
358     size.width = isSVGW3CTest ? 480 : maxViewWidth;
359     size.height = isSVGW3CTest ? 360 : maxViewHeight;
360     gtk_widget_size_allocate(GTK_WIDGET(webView), &size);
361
362     if (prevTestBFItem)
363         g_object_unref(prevTestBFItem);
364     WebKitWebBackForwardList* bfList = webkit_web_view_get_back_forward_list(webView);
365     prevTestBFItem = webkit_web_back_forward_list_get_current_item(bfList);
366     if (prevTestBFItem)
367         g_object_ref(prevTestBFItem);
368
369
370     webkit_web_view_open(webView, url);
371
372     g_free(url);
373     url = NULL;
374
375     while (!done)
376         g_main_context_iteration(NULL, TRUE);
377
378     // A blank load seems to be necessary to reset state after certain tests.
379     webkit_web_view_open(webView, "about:blank");
380
381     gLayoutTestController->deref();
382     gLayoutTestController = 0;
383 }
384
385 void webViewLoadStarted(WebKitWebView* view, WebKitWebFrame* frame, void*)
386 {
387     // Make sure we only set this once per test.  If it gets cleared, and then set again, we might
388     // end up doing two dumps for one test.
389     if (!topLoadingFrame && !done)
390         topLoadingFrame = frame;
391 }
392
393 static gboolean processWork(void* data)
394 {
395     // if we finish all the commands, we're ready to dump state
396     if (WorkQueue::shared()->processWork() && !gLayoutTestController->waitToDump())
397         dump();
398
399     return FALSE;
400 }
401
402 static void webViewLoadFinished(WebKitWebView* view, WebKitWebFrame* frame, void*)
403 {
404     if (frame != topLoadingFrame)
405         return;
406
407     topLoadingFrame = 0;
408     WorkQueue::shared()->setFrozen(true); // first complete load freezes the queue for the rest of this test
409     if (gLayoutTestController->waitToDump())
410         return;
411
412     if (WorkQueue::shared()->count())
413         g_timeout_add(0, processWork, 0);
414      else
415         dump();
416 }
417
418 static void webViewWindowObjectCleared(WebKitWebView* view, WebKitWebFrame* frame, JSGlobalContextRef context, JSObjectRef windowObject, gpointer data)
419 {
420     JSValueRef exception = 0;
421     assert(gLayoutTestController);
422
423     gLayoutTestController->makeWindowObject(context, windowObject, &exception);
424     assert(!exception);
425 }
426
427 static gboolean webViewConsoleMessage(WebKitWebView* view, const gchar* message, unsigned int line, const gchar* sourceId, gpointer data)
428 {
429     fprintf(stdout, "CONSOLE MESSAGE: line %d: %s\n", line, message);
430     return TRUE;
431 }
432
433
434 static gboolean webViewScriptAlert(WebKitWebView* view, WebKitWebFrame* frame, const gchar* message, gpointer data)
435 {
436     fprintf(stdout, "ALERT: %s\n", message);
437     return TRUE;
438 }
439
440 static gboolean webViewScriptPrompt(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, const gchar* defaultValue, gchar** value, gpointer data)
441 {
442     fprintf(stdout, "PROMPT: %s, default text: %s\n", message, defaultValue);
443     *value = g_strdup(defaultValue);
444     return TRUE;
445 }
446
447 static gboolean webViewScriptConfirm(WebKitWebView* view, WebKitWebFrame* frame, const gchar* message, gboolean* didConfirm, gpointer data)
448 {
449     fprintf(stdout, "CONFIRM: %s\n", message);
450     *didConfirm = TRUE;
451     return TRUE;
452 }
453
454 static void webViewTitleChanged(WebKitWebView* view, WebKitWebFrame* frame, const gchar* title, gpointer data)
455 {
456     if (gLayoutTestController->dumpTitleChanges() && !done)
457         printf("TITLE CHANGED: %s\n", title ? title : "");
458 }
459
460 int main(int argc, char* argv[])
461 {
462     g_thread_init(NULL);
463     gtk_init(&argc, &argv);
464
465     struct option options[] = {
466         {"notree", no_argument, &dumpTree, false},
467         {"pixel-tests", no_argument, &dumpPixels, true},
468         {"tree", no_argument, &dumpTree, true},
469         {NULL, 0, NULL, 0}
470     };
471
472     int option;
473     while ((option = getopt_long(argc, (char* const*)argv, "", options, NULL)) != -1)
474         switch (option) {
475             case '?':   // unknown or ambiguous option
476             case ':':   // missing argument
477                 exit(1);
478                 break;
479         }
480
481     GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP);
482     GtkContainer* container = GTK_CONTAINER(gtk_fixed_new());
483     gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(container));
484     gtk_widget_realize(window);
485
486     webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
487     gtk_container_add(container, GTK_WIDGET(webView));
488     gtk_widget_realize(GTK_WIDGET(webView));
489     mainFrame = webkit_web_view_get_main_frame(webView);
490
491     g_signal_connect(G_OBJECT(webView), "load-started", G_CALLBACK(webViewLoadStarted), 0);
492     g_signal_connect(G_OBJECT(webView), "load-finished", G_CALLBACK(webViewLoadFinished), 0);
493     g_signal_connect(G_OBJECT(webView), "window-object-cleared", G_CALLBACK(webViewWindowObjectCleared), 0);
494     g_signal_connect(G_OBJECT(webView), "console-message", G_CALLBACK(webViewConsoleMessage), 0);
495     g_signal_connect(G_OBJECT(webView), "script-alert", G_CALLBACK(webViewScriptAlert), 0);
496     g_signal_connect(G_OBJECT(webView), "script-prompt", G_CALLBACK(webViewScriptPrompt), 0);
497     g_signal_connect(G_OBJECT(webView), "script-confirm", G_CALLBACK(webViewScriptConfirm), 0);
498     g_signal_connect(G_OBJECT(webView), "title-changed", G_CALLBACK(webViewTitleChanged), 0);
499
500     setDefaultsToConsistentStateValuesForTesting();
501
502     if (argc == optind+1 && strcmp(argv[optind], "-") == 0) {
503         char filenameBuffer[2048];
504         printSeparators = true;
505         while (fgets(filenameBuffer, sizeof(filenameBuffer), stdin)) {
506             char* newLineCharacter = strchr(filenameBuffer, '\n');
507             if (newLineCharacter)
508                 *newLineCharacter = '\0';
509
510             if (strlen(filenameBuffer) == 0)
511                 continue;
512
513             runTest(filenameBuffer);
514         }
515     } else {
516         printSeparators = (optind < argc-1 || (dumpPixels && dumpTree));
517         for (int i = optind; i != argc; ++i)
518             runTest(argv[i]);
519     }
520
521     return 0;
522 }