Imported WebKit commit 2ea9d364d0f6efa8fa64acf19f451504c59be0e4 (http://svn.webkit.org/repository/webkit/trunk@104285)

1 files changed, 663 insertions, 0 deletions

diff --git a/Source/WebKit2/UIProcess/API/C/WKPage.cpp b/Source/WebKit2/UIProcess/API/C/WKPage.cpp
new file mode 100644
index 000000000..9c7a02916
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/C/WKPage.cpp
@@ -0,0 +1,663 @@
+/*
+ * Copyright (C) 2010 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.
+ *
+ * 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 "WKPage.h"
+#include "WKPagePrivate.h"
+
+#include "PrintInfo.h"
+#include "WKAPICast.h"
+#include "WebBackForwardList.h"
+#include "WebData.h"
+#include "WebPageProxy.h"
+#include "WebProcessProxy.h"
+#include <WebCore/Page.h>
+
+#ifdef __BLOCKS__
+#include <Block.h>
+#endif
+
+using namespace WebCore;
+using namespace WebKit;
+
+WKTypeID WKPageGetTypeID()
+{
+    return toAPI(WebPageProxy::APIType);
+}
+
+WKContextRef WKPageGetContext(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->process()->context());
+}
+
+WKPageGroupRef WKPageGetPageGroup(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->pageGroup());
+}
+
+void WKPageLoadURL(WKPageRef pageRef, WKURLRef URLRef)
+{
+    toImpl(pageRef)->loadURL(toWTFString(URLRef));
+}
+
+void WKPageLoadURLRequest(WKPageRef pageRef, WKURLRequestRef urlRequestRef)
+{
+    toImpl(pageRef)->loadURLRequest(toImpl(urlRequestRef));    
+}
+
+void WKPageLoadHTMLString(WKPageRef pageRef, WKStringRef htmlStringRef, WKURLRef baseURLRef)
+{
+    toImpl(pageRef)->loadHTMLString(toWTFString(htmlStringRef), toWTFString(baseURLRef));
+}
+
+void WKPageLoadAlternateHTMLString(WKPageRef pageRef, WKStringRef htmlStringRef, WKURLRef baseURLRef, WKURLRef unreachableURLRef)
+{
+    toImpl(pageRef)->loadAlternateHTMLString(toWTFString(htmlStringRef), toWTFString(baseURLRef), toWTFString(unreachableURLRef));
+}
+
+void WKPageLoadPlainTextString(WKPageRef pageRef, WKStringRef plainTextStringRef)
+{
+    toImpl(pageRef)->loadPlainTextString(toWTFString(plainTextStringRef));    
+}
+
+void WKPageStopLoading(WKPageRef pageRef)
+{
+    toImpl(pageRef)->stopLoading();
+}
+
+void WKPageReload(WKPageRef pageRef)
+{
+    toImpl(pageRef)->reload(false);
+}
+
+void WKPageReloadFromOrigin(WKPageRef pageRef)
+{
+    toImpl(pageRef)->reload(true);
+}
+
+bool WKPageTryClose(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->tryClose();
+}
+
+void WKPageClose(WKPageRef pageRef)
+{
+    toImpl(pageRef)->close();
+}
+
+bool WKPageIsClosed(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->isClosed();
+}
+
+void WKPageGoForward(WKPageRef pageRef)
+{
+    toImpl(pageRef)->goForward();
+}
+
+bool WKPageCanGoForward(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->canGoForward();
+}
+
+void WKPageGoBack(WKPageRef pageRef)
+{
+    toImpl(pageRef)->goBack();
+}
+
+bool WKPageCanGoBack(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->canGoBack();
+}
+
+void WKPageGoToBackForwardListItem(WKPageRef pageRef, WKBackForwardListItemRef itemRef)
+{
+    toImpl(pageRef)->goToBackForwardItem(toImpl(itemRef));
+}
+
+void WKPageTryRestoreScrollPosition(WKPageRef pageRef)
+{
+    toImpl(pageRef)->tryRestoreScrollPosition();
+}
+
+WKBackForwardListRef WKPageGetBackForwardList(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->backForwardList());
+}
+
+bool WKPageWillHandleHorizontalScrollEvents(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->willHandleHorizontalScrollEvents();
+}
+
+WKStringRef WKPageCopyTitle(WKPageRef pageRef)
+{
+    return toCopiedAPI(toImpl(pageRef)->pageTitle());
+}
+
+WKFrameRef WKPageGetMainFrame(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->mainFrame());
+}
+
+WKFrameRef WKPageGetFocusedFrame(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->focusedFrame());
+}
+
+WKFrameRef WKPageGetFrameSetLargestFrame(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->frameSetLargestFrame());
+}
+
+uint64_t WKPageGetRenderTreeSize(WKPageRef page)
+{
+    return toImpl(page)->renderTreeSize();
+}
+
+#if defined(ENABLE_INSPECTOR) && ENABLE_INSPECTOR
+WKInspectorRef WKPageGetInspector(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->inspector());
+}
+#endif
+
+double WKPageGetEstimatedProgress(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->estimatedProgress();
+}
+
+void WKPageSetMemoryCacheClientCallsEnabled(WKPageRef pageRef, bool memoryCacheClientCallsEnabled)
+{
+    toImpl(pageRef)->setMemoryCacheClientCallsEnabled(memoryCacheClientCallsEnabled);
+}
+
+WKStringRef WKPageCopyUserAgent(WKPageRef pageRef)
+{
+    return toCopiedAPI(toImpl(pageRef)->userAgent());
+}
+
+WKStringRef WKPageCopyApplicationNameForUserAgent(WKPageRef pageRef)
+{
+    return toCopiedAPI(toImpl(pageRef)->applicationNameForUserAgent());
+}
+
+void WKPageSetApplicationNameForUserAgent(WKPageRef pageRef, WKStringRef applicationNameRef)
+{
+    toImpl(pageRef)->setApplicationNameForUserAgent(toWTFString(applicationNameRef));
+}
+
+WKStringRef WKPageCopyCustomUserAgent(WKPageRef pageRef)
+{
+    return toCopiedAPI(toImpl(pageRef)->customUserAgent());
+}
+
+void WKPageSetCustomUserAgent(WKPageRef pageRef, WKStringRef userAgentRef)
+{
+    toImpl(pageRef)->setCustomUserAgent(toWTFString(userAgentRef));
+}
+
+bool WKPageSupportsTextEncoding(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->supportsTextEncoding();
+}
+
+WKStringRef WKPageCopyCustomTextEncodingName(WKPageRef pageRef)
+{
+    return toCopiedAPI(toImpl(pageRef)->customTextEncodingName());
+}
+
+void WKPageSetCustomTextEncodingName(WKPageRef pageRef, WKStringRef encodingNameRef)
+{
+    toImpl(pageRef)->setCustomTextEncodingName(toWTFString(encodingNameRef));
+}
+
+void WKPageTerminate(WKPageRef pageRef)
+{
+    toImpl(pageRef)->terminateProcess();
+}
+
+WKStringRef WKPageGetSessionHistoryURLValueType()
+{
+    static WebString* sessionHistoryURLValueType = WebString::create("SessionHistoryURL").leakRef();
+    return toAPI(sessionHistoryURLValueType);
+}
+
+WKDataRef WKPageCopySessionState(WKPageRef pageRef, void *context, WKPageSessionStateFilterCallback filter)
+{
+    return toAPI(toImpl(pageRef)->sessionStateData(filter, context).leakRef());
+}
+
+void WKPageRestoreFromSessionState(WKPageRef pageRef, WKDataRef sessionStateData)
+{
+    toImpl(pageRef)->restoreFromSessionStateData(toImpl(sessionStateData));
+}
+
+double WKPageGetTextZoomFactor(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->textZoomFactor();
+}
+
+double WKPageGetBackingScaleFactor(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->deviceScaleFactor();
+}
+
+void WKPageSetCustomBackingScaleFactor(WKPageRef pageRef, double customScaleFactor)
+{
+    toImpl(pageRef)->setCustomDeviceScaleFactor(customScaleFactor);
+}
+
+bool WKPageSupportsTextZoom(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->supportsTextZoom();
+}
+
+void WKPageSetTextZoomFactor(WKPageRef pageRef, double zoomFactor)
+{
+    toImpl(pageRef)->setTextZoomFactor(zoomFactor);
+}
+
+double WKPageGetPageZoomFactor(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->pageZoomFactor();
+}
+
+void WKPageSetPageZoomFactor(WKPageRef pageRef, double zoomFactor)
+{
+    toImpl(pageRef)->setPageZoomFactor(zoomFactor);
+}
+
+void WKPageSetPageAndTextZoomFactors(WKPageRef pageRef, double pageZoomFactor, double textZoomFactor)
+{
+    toImpl(pageRef)->setPageAndTextZoomFactors(pageZoomFactor, textZoomFactor);
+}
+
+void WKPageSetScaleFactor(WKPageRef pageRef, double scale, WKPoint origin)
+{
+    toImpl(pageRef)->scalePage(scale, toIntPoint(origin));
+}
+
+double WKPageGetScaleFactor(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->pageScaleFactor();
+}
+
+void WKPageSetUseFixedLayout(WKPageRef pageRef, bool fixed)
+{
+    toImpl(pageRef)->setUseFixedLayout(fixed);
+}
+
+void WKPageSetFixedLayoutSize(WKPageRef pageRef, WKSize size)
+{
+    toImpl(pageRef)->setFixedLayoutSize(toIntSize(size));
+}
+
+bool WKPageUseFixedLayout(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->useFixedLayout();
+}
+
+WKSize WKPageFixedLayoutSize(WKPageRef pageRef)
+{
+    return toAPI(toImpl(pageRef)->fixedLayoutSize());
+}
+
+bool WKPageHasHorizontalScrollbar(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->hasHorizontalScrollbar();
+}
+
+bool WKPageHasVerticalScrollbar(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->hasVerticalScrollbar();
+}
+
+bool WKPageIsPinnedToLeftSide(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->isPinnedToLeftSide();
+}
+
+bool WKPageIsPinnedToRightSide(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->isPinnedToRightSide();
+}
+
+void WKPageSetPaginationMode(WKPageRef pageRef, WKPaginationMode paginationMode)
+{
+    Page::Pagination::Mode mode;
+    switch (paginationMode) {
+    case kWKPaginationModeUnpaginated:
+        mode = Page::Pagination::Unpaginated;
+        break;
+    case kWKPaginationModeHorizontal:
+        mode = Page::Pagination::HorizontallyPaginated;
+        break;
+    case kWKPaginationModeVertical:
+        mode = Page::Pagination::VerticallyPaginated;
+        break;
+    default:
+        return;
+    }
+    toImpl(pageRef)->setPaginationMode(mode);
+}
+
+WKPaginationMode WKPageGetPaginationMode(WKPageRef pageRef)
+{
+    switch (toImpl(pageRef)->paginationMode()) {
+    case Page::Pagination::Unpaginated:
+        return kWKPaginationModeUnpaginated;
+    case Page::Pagination::HorizontallyPaginated:
+        return kWKPaginationModeHorizontal;
+    case Page::Pagination::VerticallyPaginated:
+        return kWKPaginationModeVertical;
+    }
+
+    ASSERT_NOT_REACHED();
+    return kWKPaginationModeUnpaginated;
+}
+
+void WKPageSetPageLength(WKPageRef pageRef, double pageLength)
+{
+    toImpl(pageRef)->setPageLength(pageLength);
+}
+
+double WKPageGetPageLength(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->pageLength();
+}
+
+void WKPageSetGapBetweenPages(WKPageRef pageRef, double gap)
+{
+    toImpl(pageRef)->setGapBetweenPages(gap);
+}
+
+double WKPageGetGapBetweenPages(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->gapBetweenPages();
+}
+
+unsigned WKPageGetPageCount(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->pageCount();
+}
+
+bool WKPageCanDelete(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->canDelete();
+}
+
+bool WKPageHasSelectedRange(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->hasSelectedRange();
+}
+
+bool WKPageIsContentEditable(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->isContentEditable();
+}
+
+void WKPageSetMaintainsInactiveSelection(WKPageRef pageRef, bool newValue)
+{
+    return toImpl(pageRef)->setMaintainsInactiveSelection(newValue);
+}
+
+void WKPageCenterSelectionInVisibleArea(WKPageRef pageRef)
+{
+    return toImpl(pageRef)->centerSelectionInVisibleArea();
+}
+
+void WKPageFindString(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
+{
+    toImpl(pageRef)->findString(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
+}
+
+void WKPageHideFindUI(WKPageRef pageRef)
+{
+    toImpl(pageRef)->hideFindUI();
+}
+
+void WKPageCountStringMatches(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
+{
+    toImpl(pageRef)->countStringMatches(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
+}
+
+void WKPageSetPageContextMenuClient(WKPageRef pageRef, const WKPageContextMenuClient* wkClient)
+{
+    toImpl(pageRef)->initializeContextMenuClient(wkClient);
+}
+
+void WKPageSetPageFindClient(WKPageRef pageRef, const WKPageFindClient* wkClient)
+{
+    toImpl(pageRef)->initializeFindClient(wkClient);
+}
+
+void WKPageSetPageFormClient(WKPageRef pageRef, const WKPageFormClient* wkClient)
+{
+    toImpl(pageRef)->initializeFormClient(wkClient);
+}
+
+void WKPageSetPageLoaderClient(WKPageRef pageRef, const WKPageLoaderClient* wkClient)
+{
+    toImpl(pageRef)->initializeLoaderClient(wkClient);
+}
+
+void WKPageSetPagePolicyClient(WKPageRef pageRef, const WKPagePolicyClient* wkClient)
+{
+    toImpl(pageRef)->initializePolicyClient(wkClient);
+}
+
+void WKPageSetPageResourceLoadClient(WKPageRef pageRef, const WKPageResourceLoadClient* wkClient)
+{
+    toImpl(pageRef)->initializeResourceLoadClient(wkClient);
+}
+
+void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClient* wkClient)
+{
+    toImpl(pageRef)->initializeUIClient(wkClient);
+}
+
+void WKPageRunJavaScriptInMainFrame(WKPageRef pageRef, WKStringRef scriptRef, void* context, WKPageRunJavaScriptFunction callback)
+{
+    toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), ScriptValueCallback::create(context, callback));
+}
+
+#ifdef __BLOCKS__
+static void callRunJavaScriptBlockAndRelease(WKSerializedScriptValueRef resultValue, WKErrorRef error, void* context)
+{
+    WKPageRunJavaScriptBlock block = (WKPageRunJavaScriptBlock)context;
+    block(resultValue, error);
+    Block_release(block);
+}
+
+void WKPageRunJavaScriptInMainFrame_b(WKPageRef pageRef, WKStringRef scriptRef, WKPageRunJavaScriptBlock block)
+{
+    WKPageRunJavaScriptInMainFrame(pageRef, scriptRef, Block_copy(block), callRunJavaScriptBlockAndRelease);
+}
+#endif
+
+void WKPageRenderTreeExternalRepresentation(WKPageRef pageRef, void* context, WKPageRenderTreeExternalRepresentationFunction callback)
+{
+    toImpl(pageRef)->getRenderTreeExternalRepresentation(StringCallback::create(context, callback));
+}
+
+#ifdef __BLOCKS__
+static void callRenderTreeExternalRepresentationBlockAndDispose(WKStringRef resultValue, WKErrorRef error, void* context)
+{
+    WKPageRenderTreeExternalRepresentationBlock block = (WKPageRenderTreeExternalRepresentationBlock)context;
+    block(resultValue, error);
+    Block_release(block);
+}
+
+void WKPageRenderTreeExternalRepresentation_b(WKPageRef pageRef, WKPageRenderTreeExternalRepresentationBlock block)
+{
+    WKPageRenderTreeExternalRepresentation(pageRef, Block_copy(block), callRenderTreeExternalRepresentationBlockAndDispose);
+}
+#endif
+
+void WKPageGetSourceForFrame(WKPageRef pageRef, WKFrameRef frameRef, void* context, WKPageGetSourceForFrameFunction callback)
+{
+    toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), StringCallback::create(context, callback));
+}
+
+#ifdef __BLOCKS__
+static void callGetSourceForFrameBlockBlockAndDispose(WKStringRef resultValue, WKErrorRef error, void* context)
+{
+    WKPageGetSourceForFrameBlock block = (WKPageGetSourceForFrameBlock)context;
+    block(resultValue, error);
+    Block_release(block);
+}
+
+void WKPageGetSourceForFrame_b(WKPageRef pageRef, WKFrameRef frameRef, WKPageGetSourceForFrameBlock block)
+{
+    WKPageGetSourceForFrame(pageRef, frameRef, Block_copy(block), callGetSourceForFrameBlockBlockAndDispose);
+}
+#endif
+
+void WKPageGetContentsAsString(WKPageRef pageRef, void* context, WKPageGetContentsAsStringFunction callback)
+{
+    toImpl(pageRef)->getContentsAsString(StringCallback::create(context, callback));
+}
+
+#ifdef __BLOCKS__
+static void callContentsAsStringBlockBlockAndDispose(WKStringRef resultValue, WKErrorRef error, void* context)
+{
+    WKPageGetContentsAsStringBlock block = (WKPageGetContentsAsStringBlock)context;
+    block(resultValue, error);
+    Block_release(block);
+}
+
+void WKPageGetContentsAsString_b(WKPageRef pageRef, WKPageGetSourceForFrameBlock block)
+{
+    WKPageGetContentsAsString(pageRef, Block_copy(block), callContentsAsStringBlockBlockAndDispose);
+}
+#endif
+
+void WKPageForceRepaint(WKPageRef pageRef, void* context, WKPageForceRepaintFunction callback)
+{
+    toImpl(pageRef)->forceRepaint(VoidCallback::create(context, callback));
+}
+
+WK_EXPORT WKURLRef WKPageCopyPendingAPIRequestURL(WKPageRef pageRef)
+{
+    if (toImpl(pageRef)->pendingAPIRequestURL().isNull())
+        return 0;
+    return toCopiedURLAPI(toImpl(pageRef)->pendingAPIRequestURL());
+}
+
+WKURLRef WKPageCopyActiveURL(WKPageRef pageRef)
+{
+    return toCopiedURLAPI(toImpl(pageRef)->activeURL());
+}
+
+WKURLRef WKPageCopyProvisionalURL(WKPageRef pageRef)
+{
+    return toCopiedURLAPI(toImpl(pageRef)->provisionalURL());
+}
+
+WKURLRef WKPageCopyCommittedURL(WKPageRef pageRef)
+{
+    return toCopiedURLAPI(toImpl(pageRef)->committedURL());
+}
+
+void WKPageSetDebugPaintFlags(WKPageDebugPaintFlags flags)
+{
+    WebPageProxy::setDebugPaintFlags(flags);
+}
+
+WKPageDebugPaintFlags WKPageGetDebugPaintFlags()
+{
+    return WebPageProxy::debugPaintFlags();
+}
+
+WKStringRef WKPageCopyStandardUserAgentWithApplicationName(WKStringRef applicationName)
+{
+    return toCopiedAPI(WebPageProxy::standardUserAgent(toImpl(applicationName)->string()));
+}
+
+void WKPageValidateCommand(WKPageRef pageRef, WKStringRef command, void* context, WKPageValidateCommandCallback callback)
+{
+    toImpl(pageRef)->validateCommand(toImpl(command)->string(), ValidateCommandCallback::create(context, callback)); 
+}
+
+void WKPageExecuteCommand(WKPageRef pageRef, WKStringRef command)
+{
+    toImpl(pageRef)->executeEditCommand(toImpl(command)->string());
+}
+
+#if PLATFORM(MAC) || PLATFORM(WIN)
+struct ComputedPagesContext {
+    ComputedPagesContext(WKPageComputePagesForPrintingFunction callback, void* context)
+        : callback(callback)
+        , context(context)
+    {
+    }
+    WKPageComputePagesForPrintingFunction callback;
+    void* context;
+};
+
+static void computedPagesCallback(const Vector<WebCore::IntRect>& rects, double scaleFactor, WKErrorRef error, void* untypedContext)
+{
+    OwnPtr<ComputedPagesContext> context = adoptPtr(static_cast<ComputedPagesContext*>(untypedContext));
+    Vector<WKRect> wkRects(rects.size());
+    for (size_t i = 0; i < rects.size(); ++i)
+        wkRects[i] = toAPI(rects[i]);
+    context->callback(wkRects.data(), wkRects.size(), scaleFactor, error, context->context);
+}
+
+static PrintInfo printInfoFromWKPrintInfo(const WKPrintInfo& printInfo)
+{
+    PrintInfo result;
+    result.pageSetupScaleFactor = printInfo.pageSetupScaleFactor;
+    result.availablePaperWidth = printInfo.availablePaperWidth;
+    result.availablePaperHeight = printInfo.availablePaperHeight;
+    return result;
+}
+
+void WKPageComputePagesForPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, WKPageComputePagesForPrintingFunction callback, void* context)
+{
+    toImpl(page)->computePagesForPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo), ComputedPagesCallback::create(new ComputedPagesContext(callback, context), computedPagesCallback));
+}
+
+void WKPageBeginPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo)
+{
+    toImpl(page)->beginPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo));
+}
+
+void WKPageDrawPagesToPDF(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, uint32_t first, uint32_t count, WKPageDrawToPDFFunction callback, void* context)
+{
+    toImpl(page)->drawPagesToPDF(toImpl(frame), printInfoFromWKPrintInfo(printInfo), first, count, DataCallback::create(context, callback));
+}
+#endif
+
+WKImageRef WKPageCreateSnapshotOfVisibleContent(WKPageRef)
+{
+    return 0;
+}
+
+void WKPageSetShouldSendEventsSynchronously(WKPageRef page, bool sync)
+{
+    toImpl(page)->setShouldSendEventsSynchronously(sync);
+}