Entering Tab View after a bunch of YouTube pages were opened in background tabs makes...
[WebKit-https.git] / Source / WebKit2 / UIProcess / API / C / WKPage.cpp
1 /*
2  * Copyright (C) 2010 Apple 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WKPage.h"
28 #include "WKPagePrivate.h"
29
30 #include "PrintInfo.h"
31 #include "WKAPICast.h"
32 #include "WebBackForwardList.h"
33 #include "WebData.h"
34 #include "WebPageProxy.h"
35 #include "WebProcessProxy.h"
36 #include <WebCore/Page.h>
37
38 #ifdef __BLOCKS__
39 #include <Block.h>
40 #endif
41
42 using namespace WebCore;
43 using namespace WebKit;
44
45 WKTypeID WKPageGetTypeID()
46 {
47     return toAPI(WebPageProxy::APIType);
48 }
49
50 WKContextRef WKPageGetContext(WKPageRef pageRef)
51 {
52     return toAPI(toImpl(pageRef)->process()->context());
53 }
54
55 WKPageGroupRef WKPageGetPageGroup(WKPageRef pageRef)
56 {
57     return toAPI(toImpl(pageRef)->pageGroup());
58 }
59
60 void WKPageLoadURL(WKPageRef pageRef, WKURLRef URLRef)
61 {
62     toImpl(pageRef)->loadURL(toWTFString(URLRef));
63 }
64
65 void WKPageLoadURLRequest(WKPageRef pageRef, WKURLRequestRef urlRequestRef)
66 {
67     toImpl(pageRef)->loadURLRequest(toImpl(urlRequestRef));    
68 }
69
70 void WKPageLoadHTMLString(WKPageRef pageRef, WKStringRef htmlStringRef, WKURLRef baseURLRef)
71 {
72     toImpl(pageRef)->loadHTMLString(toWTFString(htmlStringRef), toWTFString(baseURLRef));
73 }
74
75 void WKPageLoadAlternateHTMLString(WKPageRef pageRef, WKStringRef htmlStringRef, WKURLRef baseURLRef, WKURLRef unreachableURLRef)
76 {
77     toImpl(pageRef)->loadAlternateHTMLString(toWTFString(htmlStringRef), toWTFString(baseURLRef), toWTFString(unreachableURLRef));
78 }
79
80 void WKPageLoadPlainTextString(WKPageRef pageRef, WKStringRef plainTextStringRef)
81 {
82     toImpl(pageRef)->loadPlainTextString(toWTFString(plainTextStringRef));    
83 }
84
85 void WKPageLoadWebArchiveData(WKPageRef pageRef, WKDataRef webArchiveDataRef)
86 {
87     toImpl(pageRef)->loadWebArchiveData(toImpl(webArchiveDataRef));
88 }
89
90 void WKPageStopLoading(WKPageRef pageRef)
91 {
92     toImpl(pageRef)->stopLoading();
93 }
94
95 void WKPageReload(WKPageRef pageRef)
96 {
97     toImpl(pageRef)->reload(false);
98 }
99
100 void WKPageReloadFromOrigin(WKPageRef pageRef)
101 {
102     toImpl(pageRef)->reload(true);
103 }
104
105 bool WKPageTryClose(WKPageRef pageRef)
106 {
107     return toImpl(pageRef)->tryClose();
108 }
109
110 void WKPageClose(WKPageRef pageRef)
111 {
112     toImpl(pageRef)->close();
113 }
114
115 bool WKPageIsClosed(WKPageRef pageRef)
116 {
117     return toImpl(pageRef)->isClosed();
118 }
119
120 void WKPageGoForward(WKPageRef pageRef)
121 {
122     toImpl(pageRef)->goForward();
123 }
124
125 bool WKPageCanGoForward(WKPageRef pageRef)
126 {
127     return toImpl(pageRef)->canGoForward();
128 }
129
130 void WKPageGoBack(WKPageRef pageRef)
131 {
132     toImpl(pageRef)->goBack();
133 }
134
135 bool WKPageCanGoBack(WKPageRef pageRef)
136 {
137     return toImpl(pageRef)->canGoBack();
138 }
139
140 void WKPageGoToBackForwardListItem(WKPageRef pageRef, WKBackForwardListItemRef itemRef)
141 {
142     toImpl(pageRef)->goToBackForwardItem(toImpl(itemRef));
143 }
144
145 void WKPageTryRestoreScrollPosition(WKPageRef pageRef)
146 {
147     toImpl(pageRef)->tryRestoreScrollPosition();
148 }
149
150 WKBackForwardListRef WKPageGetBackForwardList(WKPageRef pageRef)
151 {
152     return toAPI(toImpl(pageRef)->backForwardList());
153 }
154
155 bool WKPageWillHandleHorizontalScrollEvents(WKPageRef pageRef)
156 {
157     return toImpl(pageRef)->willHandleHorizontalScrollEvents();
158 }
159
160 WKStringRef WKPageCopyTitle(WKPageRef pageRef)
161 {
162     return toCopiedAPI(toImpl(pageRef)->pageTitle());
163 }
164
165 WKFrameRef WKPageGetMainFrame(WKPageRef pageRef)
166 {
167     return toAPI(toImpl(pageRef)->mainFrame());
168 }
169
170 WKFrameRef WKPageGetFocusedFrame(WKPageRef pageRef)
171 {
172     return toAPI(toImpl(pageRef)->focusedFrame());
173 }
174
175 WKFrameRef WKPageGetFrameSetLargestFrame(WKPageRef pageRef)
176 {
177     return toAPI(toImpl(pageRef)->frameSetLargestFrame());
178 }
179
180 uint64_t WKPageGetRenderTreeSize(WKPageRef page)
181 {
182     return toImpl(page)->renderTreeSize();
183 }
184
185 WKInspectorRef WKPageGetInspector(WKPageRef pageRef)
186 {
187 #if defined(ENABLE_INSPECTOR) && ENABLE_INSPECTOR
188     return toAPI(toImpl(pageRef)->inspector());
189 #else
190     return 0;
191 #endif
192 }
193
194 WKVibrationRef WKPageGetVibration(WKPageRef page)
195 {
196 #if ENABLE(VIBRATION)
197     return toAPI(toImpl(page)->vibration());
198 #else
199     UNUSED_PARAM(page);
200     return 0;
201 #endif
202 }
203
204 double WKPageGetEstimatedProgress(WKPageRef pageRef)
205 {
206     return toImpl(pageRef)->estimatedProgress();
207 }
208
209 void WKPageSetMemoryCacheClientCallsEnabled(WKPageRef pageRef, bool memoryCacheClientCallsEnabled)
210 {
211     toImpl(pageRef)->setMemoryCacheClientCallsEnabled(memoryCacheClientCallsEnabled);
212 }
213
214 WKStringRef WKPageCopyUserAgent(WKPageRef pageRef)
215 {
216     return toCopiedAPI(toImpl(pageRef)->userAgent());
217 }
218
219 WKStringRef WKPageCopyApplicationNameForUserAgent(WKPageRef pageRef)
220 {
221     return toCopiedAPI(toImpl(pageRef)->applicationNameForUserAgent());
222 }
223
224 void WKPageSetApplicationNameForUserAgent(WKPageRef pageRef, WKStringRef applicationNameRef)
225 {
226     toImpl(pageRef)->setApplicationNameForUserAgent(toWTFString(applicationNameRef));
227 }
228
229 WKStringRef WKPageCopyCustomUserAgent(WKPageRef pageRef)
230 {
231     return toCopiedAPI(toImpl(pageRef)->customUserAgent());
232 }
233
234 void WKPageSetCustomUserAgent(WKPageRef pageRef, WKStringRef userAgentRef)
235 {
236     toImpl(pageRef)->setCustomUserAgent(toWTFString(userAgentRef));
237 }
238
239 bool WKPageSupportsTextEncoding(WKPageRef pageRef)
240 {
241     return toImpl(pageRef)->supportsTextEncoding();
242 }
243
244 WKStringRef WKPageCopyCustomTextEncodingName(WKPageRef pageRef)
245 {
246     return toCopiedAPI(toImpl(pageRef)->customTextEncodingName());
247 }
248
249 void WKPageSetCustomTextEncodingName(WKPageRef pageRef, WKStringRef encodingNameRef)
250 {
251     toImpl(pageRef)->setCustomTextEncodingName(toWTFString(encodingNameRef));
252 }
253
254 void WKPageTerminate(WKPageRef pageRef)
255 {
256     toImpl(pageRef)->terminateProcess();
257 }
258
259 WKStringRef WKPageGetSessionHistoryURLValueType()
260 {
261     static WebString* sessionHistoryURLValueType = WebString::create("SessionHistoryURL").leakRef();
262     return toAPI(sessionHistoryURLValueType);
263 }
264
265 WKDataRef WKPageCopySessionState(WKPageRef pageRef, void *context, WKPageSessionStateFilterCallback filter)
266 {
267     return toAPI(toImpl(pageRef)->sessionStateData(filter, context).leakRef());
268 }
269
270 void WKPageRestoreFromSessionState(WKPageRef pageRef, WKDataRef sessionStateData)
271 {
272     toImpl(pageRef)->restoreFromSessionStateData(toImpl(sessionStateData));
273 }
274
275 double WKPageGetTextZoomFactor(WKPageRef pageRef)
276 {
277     return toImpl(pageRef)->textZoomFactor();
278 }
279
280 double WKPageGetBackingScaleFactor(WKPageRef pageRef)
281 {
282     return toImpl(pageRef)->deviceScaleFactor();
283 }
284
285 void WKPageSetCustomBackingScaleFactor(WKPageRef pageRef, double customScaleFactor)
286 {
287     toImpl(pageRef)->setCustomDeviceScaleFactor(customScaleFactor);
288 }
289
290 bool WKPageSupportsTextZoom(WKPageRef pageRef)
291 {
292     return toImpl(pageRef)->supportsTextZoom();
293 }
294
295 void WKPageSetTextZoomFactor(WKPageRef pageRef, double zoomFactor)
296 {
297     toImpl(pageRef)->setTextZoomFactor(zoomFactor);
298 }
299
300 double WKPageGetPageZoomFactor(WKPageRef pageRef)
301 {
302     return toImpl(pageRef)->pageZoomFactor();
303 }
304
305 void WKPageSetPageZoomFactor(WKPageRef pageRef, double zoomFactor)
306 {
307     toImpl(pageRef)->setPageZoomFactor(zoomFactor);
308 }
309
310 void WKPageSetPageAndTextZoomFactors(WKPageRef pageRef, double pageZoomFactor, double textZoomFactor)
311 {
312     toImpl(pageRef)->setPageAndTextZoomFactors(pageZoomFactor, textZoomFactor);
313 }
314
315 void WKPageSetScaleFactor(WKPageRef pageRef, double scale, WKPoint origin)
316 {
317     toImpl(pageRef)->scalePage(scale, toIntPoint(origin));
318 }
319
320 double WKPageGetScaleFactor(WKPageRef pageRef)
321 {
322     return toImpl(pageRef)->pageScaleFactor();
323 }
324
325 void WKPageSetUseFixedLayout(WKPageRef pageRef, bool fixed)
326 {
327     toImpl(pageRef)->setUseFixedLayout(fixed);
328 }
329
330 void WKPageSetFixedLayoutSize(WKPageRef pageRef, WKSize size)
331 {
332     toImpl(pageRef)->setFixedLayoutSize(toIntSize(size));
333 }
334
335 bool WKPageUseFixedLayout(WKPageRef pageRef)
336 {
337     return toImpl(pageRef)->useFixedLayout();
338 }
339
340 WKSize WKPageFixedLayoutSize(WKPageRef pageRef)
341 {
342     return toAPI(toImpl(pageRef)->fixedLayoutSize());
343 }
344
345 void WKPageListenForLayoutMilestones(WKPageRef pageRef, WKLayoutMilestones milestones)
346 {
347     toImpl(pageRef)->listenForLayoutMilestones(toLayoutMilestones(milestones));
348 }
349
350 bool WKPageHasHorizontalScrollbar(WKPageRef pageRef)
351 {
352     return toImpl(pageRef)->hasHorizontalScrollbar();
353 }
354
355 bool WKPageHasVerticalScrollbar(WKPageRef pageRef)
356 {
357     return toImpl(pageRef)->hasVerticalScrollbar();
358 }
359
360 void WKPageSetSuppressScrollbarAnimations(WKPageRef pageRef, bool suppressAnimations)
361 {
362     toImpl(pageRef)->setSuppressScrollbarAnimations(suppressAnimations);
363 }
364
365 bool WKPageAreScrollbarAnimationsSuppressed(WKPageRef pageRef)
366 {
367     return toImpl(pageRef)->areScrollbarAnimationsSuppressed();
368 }
369
370 bool WKPageIsPinnedToLeftSide(WKPageRef pageRef)
371 {
372     return toImpl(pageRef)->isPinnedToLeftSide();
373 }
374
375 bool WKPageIsPinnedToRightSide(WKPageRef pageRef)
376 {
377     return toImpl(pageRef)->isPinnedToRightSide();
378 }
379
380 bool WKPageIsPinnedToTopSide(WKPageRef pageRef)
381 {
382     return toImpl(pageRef)->isPinnedToTopSide();
383 }
384
385 bool WKPageIsPinnedToBottomSide(WKPageRef pageRef)
386 {
387     return toImpl(pageRef)->isPinnedToBottomSide();
388 }
389
390 void WKPageSetPaginationMode(WKPageRef pageRef, WKPaginationMode paginationMode)
391 {
392     Pagination::Mode mode;
393     switch (paginationMode) {
394     case kWKPaginationModeUnpaginated:
395         mode = Pagination::Unpaginated;
396         break;
397     case kWKPaginationModeLeftToRight:
398         mode = Pagination::LeftToRightPaginated;
399         break;
400     case kWKPaginationModeRightToLeft:
401         mode = Pagination::RightToLeftPaginated;
402         break;
403     case kWKPaginationModeTopToBottom:
404         mode = Pagination::TopToBottomPaginated;
405         break;
406     case kWKPaginationModeBottomToTop:
407         mode = Pagination::BottomToTopPaginated;
408         break;
409     default:
410         return;
411     }
412     toImpl(pageRef)->setPaginationMode(mode);
413 }
414
415 WKPaginationMode WKPageGetPaginationMode(WKPageRef pageRef)
416 {
417     switch (toImpl(pageRef)->paginationMode()) {
418     case Pagination::Unpaginated:
419         return kWKPaginationModeUnpaginated;
420     case Pagination::LeftToRightPaginated:
421         return kWKPaginationModeLeftToRight;
422     case Pagination::RightToLeftPaginated:
423         return kWKPaginationModeRightToLeft;
424     case Pagination::TopToBottomPaginated:
425         return kWKPaginationModeTopToBottom;
426     case Pagination::BottomToTopPaginated:
427         return kWKPaginationModeBottomToTop;
428     }
429
430     ASSERT_NOT_REACHED();
431     return kWKPaginationModeUnpaginated;
432 }
433
434 void WKPageSetPaginationBehavesLikeColumns(WKPageRef pageRef, bool behavesLikeColumns)
435 {
436     toImpl(pageRef)->setPaginationBehavesLikeColumns(behavesLikeColumns);
437 }
438
439 bool WKPageGetPaginationBehavesLikeColumns(WKPageRef pageRef)
440 {
441     return toImpl(pageRef)->paginationBehavesLikeColumns();
442 }
443
444 void WKPageSetPageLength(WKPageRef pageRef, double pageLength)
445 {
446     toImpl(pageRef)->setPageLength(pageLength);
447 }
448
449 double WKPageGetPageLength(WKPageRef pageRef)
450 {
451     return toImpl(pageRef)->pageLength();
452 }
453
454 void WKPageSetGapBetweenPages(WKPageRef pageRef, double gap)
455 {
456     toImpl(pageRef)->setGapBetweenPages(gap);
457 }
458
459 double WKPageGetGapBetweenPages(WKPageRef pageRef)
460 {
461     return toImpl(pageRef)->gapBetweenPages();
462 }
463
464 unsigned WKPageGetPageCount(WKPageRef pageRef)
465 {
466     return toImpl(pageRef)->pageCount();
467 }
468
469 bool WKPageCanDelete(WKPageRef pageRef)
470 {
471     return toImpl(pageRef)->canDelete();
472 }
473
474 bool WKPageHasSelectedRange(WKPageRef pageRef)
475 {
476     return toImpl(pageRef)->hasSelectedRange();
477 }
478
479 bool WKPageIsContentEditable(WKPageRef pageRef)
480 {
481     return toImpl(pageRef)->isContentEditable();
482 }
483
484 void WKPageSetMaintainsInactiveSelection(WKPageRef pageRef, bool newValue)
485 {
486     return toImpl(pageRef)->setMaintainsInactiveSelection(newValue);
487 }
488
489 void WKPageCenterSelectionInVisibleArea(WKPageRef pageRef)
490 {
491     return toImpl(pageRef)->centerSelectionInVisibleArea();
492 }
493
494 void WKPageFindString(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
495 {
496     toImpl(pageRef)->findString(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
497 }
498
499 void WKPageHideFindUI(WKPageRef pageRef)
500 {
501     toImpl(pageRef)->hideFindUI();
502 }
503
504 void WKPageCountStringMatches(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
505 {
506     toImpl(pageRef)->countStringMatches(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
507 }
508
509 void WKPageSetPageContextMenuClient(WKPageRef pageRef, const WKPageContextMenuClient* wkClient)
510 {
511 #if ENABLE(CONTEXT_MENUS)
512     toImpl(pageRef)->initializeContextMenuClient(wkClient);
513 #endif
514 }
515
516 void WKPageSetPageFindClient(WKPageRef pageRef, const WKPageFindClient* wkClient)
517 {
518     toImpl(pageRef)->initializeFindClient(wkClient);
519 }
520
521 void WKPageSetPageFormClient(WKPageRef pageRef, const WKPageFormClient* wkClient)
522 {
523     toImpl(pageRef)->initializeFormClient(wkClient);
524 }
525
526 void WKPageSetPageLoaderClient(WKPageRef pageRef, const WKPageLoaderClient* wkClient)
527 {
528     toImpl(pageRef)->initializeLoaderClient(wkClient);
529 }
530
531 void WKPageSetPagePolicyClient(WKPageRef pageRef, const WKPagePolicyClient* wkClient)
532 {
533     toImpl(pageRef)->initializePolicyClient(wkClient);
534 }
535
536 void WKPageSetPageResourceLoadClient(WKPageRef pageRef, const WKPageResourceLoadClient* wkClient)
537 {
538     toImpl(pageRef)->initializeResourceLoadClient(wkClient);
539 }
540
541 void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClient* wkClient)
542 {
543     toImpl(pageRef)->initializeUIClient(wkClient);
544 }
545
546 void WKPageRunJavaScriptInMainFrame(WKPageRef pageRef, WKStringRef scriptRef, void* context, WKPageRunJavaScriptFunction callback)
547 {
548     toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), ScriptValueCallback::create(context, callback));
549 }
550
551 #ifdef __BLOCKS__
552 static void callRunJavaScriptBlockAndRelease(WKSerializedScriptValueRef resultValue, WKErrorRef error, void* context)
553 {
554     WKPageRunJavaScriptBlock block = (WKPageRunJavaScriptBlock)context;
555     block(resultValue, error);
556     Block_release(block);
557 }
558
559 void WKPageRunJavaScriptInMainFrame_b(WKPageRef pageRef, WKStringRef scriptRef, WKPageRunJavaScriptBlock block)
560 {
561     WKPageRunJavaScriptInMainFrame(pageRef, scriptRef, Block_copy(block), callRunJavaScriptBlockAndRelease);
562 }
563 #endif
564
565 void WKPageRenderTreeExternalRepresentation(WKPageRef pageRef, void* context, WKPageRenderTreeExternalRepresentationFunction callback)
566 {
567     toImpl(pageRef)->getRenderTreeExternalRepresentation(StringCallback::create(context, callback));
568 }
569
570 #ifdef __BLOCKS__
571 static void callRenderTreeExternalRepresentationBlockAndDispose(WKStringRef resultValue, WKErrorRef error, void* context)
572 {
573     WKPageRenderTreeExternalRepresentationBlock block = (WKPageRenderTreeExternalRepresentationBlock)context;
574     block(resultValue, error);
575     Block_release(block);
576 }
577
578 void WKPageRenderTreeExternalRepresentation_b(WKPageRef pageRef, WKPageRenderTreeExternalRepresentationBlock block)
579 {
580     WKPageRenderTreeExternalRepresentation(pageRef, Block_copy(block), callRenderTreeExternalRepresentationBlockAndDispose);
581 }
582 #endif
583
584 void WKPageGetSourceForFrame(WKPageRef pageRef, WKFrameRef frameRef, void* context, WKPageGetSourceForFrameFunction callback)
585 {
586     toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), StringCallback::create(context, callback));
587 }
588
589 #ifdef __BLOCKS__
590 static void callGetSourceForFrameBlockBlockAndDispose(WKStringRef resultValue, WKErrorRef error, void* context)
591 {
592     WKPageGetSourceForFrameBlock block = (WKPageGetSourceForFrameBlock)context;
593     block(resultValue, error);
594     Block_release(block);
595 }
596
597 void WKPageGetSourceForFrame_b(WKPageRef pageRef, WKFrameRef frameRef, WKPageGetSourceForFrameBlock block)
598 {
599     WKPageGetSourceForFrame(pageRef, frameRef, Block_copy(block), callGetSourceForFrameBlockBlockAndDispose);
600 }
601 #endif
602
603 void WKPageGetContentsAsString(WKPageRef pageRef, void* context, WKPageGetContentsAsStringFunction callback)
604 {
605     toImpl(pageRef)->getContentsAsString(StringCallback::create(context, callback));
606 }
607
608 #ifdef __BLOCKS__
609 static void callContentsAsStringBlockBlockAndDispose(WKStringRef resultValue, WKErrorRef error, void* context)
610 {
611     WKPageGetContentsAsStringBlock block = (WKPageGetContentsAsStringBlock)context;
612     block(resultValue, error);
613     Block_release(block);
614 }
615
616 void WKPageGetContentsAsString_b(WKPageRef pageRef, WKPageGetSourceForFrameBlock block)
617 {
618     WKPageGetContentsAsString(pageRef, Block_copy(block), callContentsAsStringBlockBlockAndDispose);
619 }
620 #endif
621
622 void WKPageGetContentsAsMHTMLData(WKPageRef pageRef, bool useBinaryEncoding, void* context, WKPageGetContentsAsMHTMLDataFunction callback)
623 {
624 #if ENABLE(MHTML)
625     toImpl(pageRef)->getContentsAsMHTMLData(DataCallback::create(context, callback), useBinaryEncoding);
626 #else
627     UNUSED_PARAM(pageRef);
628     UNUSED_PARAM(useBinaryEncoding);
629     UNUSED_PARAM(context);
630     UNUSED_PARAM(callback);
631 #endif
632 }
633
634 void WKPageForceRepaint(WKPageRef pageRef, void* context, WKPageForceRepaintFunction callback)
635 {
636     toImpl(pageRef)->forceRepaint(VoidCallback::create(context, callback));
637 }
638
639 WK_EXPORT WKURLRef WKPageCopyPendingAPIRequestURL(WKPageRef pageRef)
640 {
641     if (toImpl(pageRef)->pendingAPIRequestURL().isNull())
642         return 0;
643     return toCopiedURLAPI(toImpl(pageRef)->pendingAPIRequestURL());
644 }
645
646 WKURLRef WKPageCopyActiveURL(WKPageRef pageRef)
647 {
648     return toCopiedURLAPI(toImpl(pageRef)->activeURL());
649 }
650
651 WKURLRef WKPageCopyProvisionalURL(WKPageRef pageRef)
652 {
653     return toCopiedURLAPI(toImpl(pageRef)->provisionalURL());
654 }
655
656 WKURLRef WKPageCopyCommittedURL(WKPageRef pageRef)
657 {
658     return toCopiedURLAPI(toImpl(pageRef)->committedURL());
659 }
660
661 void WKPageSetDebugPaintFlags(WKPageDebugPaintFlags flags)
662 {
663     WebPageProxy::setDebugPaintFlags(flags);
664 }
665
666 WKPageDebugPaintFlags WKPageGetDebugPaintFlags()
667 {
668     return WebPageProxy::debugPaintFlags();
669 }
670
671 WKStringRef WKPageCopyStandardUserAgentWithApplicationName(WKStringRef applicationName)
672 {
673     return toCopiedAPI(WebPageProxy::standardUserAgent(toImpl(applicationName)->string()));
674 }
675
676 void WKPageValidateCommand(WKPageRef pageRef, WKStringRef command, void* context, WKPageValidateCommandCallback callback)
677 {
678     toImpl(pageRef)->validateCommand(toImpl(command)->string(), ValidateCommandCallback::create(context, callback)); 
679 }
680
681 void WKPageExecuteCommand(WKPageRef pageRef, WKStringRef command)
682 {
683     toImpl(pageRef)->executeEditCommand(toImpl(command)->string());
684 }
685
686 #if PLATFORM(MAC) || PLATFORM(WIN)
687 struct ComputedPagesContext {
688     ComputedPagesContext(WKPageComputePagesForPrintingFunction callback, void* context)
689         : callback(callback)
690         , context(context)
691     {
692     }
693     WKPageComputePagesForPrintingFunction callback;
694     void* context;
695 };
696
697 static void computedPagesCallback(const Vector<WebCore::IntRect>& rects, double scaleFactor, WKErrorRef error, void* untypedContext)
698 {
699     OwnPtr<ComputedPagesContext> context = adoptPtr(static_cast<ComputedPagesContext*>(untypedContext));
700     Vector<WKRect> wkRects(rects.size());
701     for (size_t i = 0; i < rects.size(); ++i)
702         wkRects[i] = toAPI(rects[i]);
703     context->callback(wkRects.data(), wkRects.size(), scaleFactor, error, context->context);
704 }
705
706 static PrintInfo printInfoFromWKPrintInfo(const WKPrintInfo& printInfo)
707 {
708     PrintInfo result;
709     result.pageSetupScaleFactor = printInfo.pageSetupScaleFactor;
710     result.availablePaperWidth = printInfo.availablePaperWidth;
711     result.availablePaperHeight = printInfo.availablePaperHeight;
712     return result;
713 }
714
715 void WKPageComputePagesForPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, WKPageComputePagesForPrintingFunction callback, void* context)
716 {
717     toImpl(page)->computePagesForPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo), ComputedPagesCallback::create(new ComputedPagesContext(callback, context), computedPagesCallback));
718 }
719
720 void WKPageBeginPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo)
721 {
722     toImpl(page)->beginPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo));
723 }
724
725 void WKPageDrawPagesToPDF(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, uint32_t first, uint32_t count, WKPageDrawToPDFFunction callback, void* context)
726 {
727     toImpl(page)->drawPagesToPDF(toImpl(frame), printInfoFromWKPrintInfo(printInfo), first, count, DataCallback::create(context, callback));
728 }
729
730 void WKPageEndPrinting(WKPageRef page)
731 {
732     toImpl(page)->endPrinting();
733 }
734 #endif
735
736 void WKPageDeliverIntentToFrame(WKPageRef page, WKFrameRef frame, WKIntentDataRef intent)
737 {
738 #if ENABLE(WEB_INTENTS)
739     toImpl(page)->deliverIntentToFrame(toImpl(frame), toImpl(intent));
740 #endif
741 }
742
743 WKImageRef WKPageCreateSnapshotOfVisibleContent(WKPageRef)
744 {
745     return 0;
746 }
747
748 void WKPageSetShouldSendEventsSynchronously(WKPageRef page, bool sync)
749 {
750     toImpl(page)->setShouldSendEventsSynchronously(sync);
751 }
752
753 void WKPageSetMediaVolume(WKPageRef page, float volume)
754 {
755     toImpl(page)->setMediaVolume(volume);    
756 }
757
758 void WKPagePostMessageToInjectedBundle(WKPageRef pageRef, WKStringRef messageNameRef, WKTypeRef messageBodyRef)
759 {
760     toImpl(pageRef)->postMessageToInjectedBundle(toImpl(messageNameRef)->string(), toImpl(messageBodyRef));
761 }
762
763 WKArrayRef WKPageCopyRelatedPages(WKPageRef pageRef)
764 {
765     return toAPI(toImpl(pageRef)->relatedPages().leakRef());
766 }
767
768 void WKPageSetMayStartMediaWhenInWindow(WKPageRef pageRef, bool mayStartMedia)
769 {
770     toImpl(pageRef)->setMayStartMediaWhenInWindow(mayStartMedia);
771 }