Attachment 356704 Details for Bug 192450 – Patch

[patch] Patch

bug-192450-20181206133842.patch (text/plain), 265.56 KB, created by Fujii Hironori on 2018-12-05 20:38:44 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Fujii Hironori

Created: 2018-12-05 20:38:44 PST

Size: 265.56 KB

patch

obsolete

>Subversion Revision: 238922
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 063a19a3eedd9868fd585fb0d6e80ecb6b182d88..750bcb2704536d777ec14ac18562639f39c293e9 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,58 @@
>+2018-12-05  Fujii Hironori  <Hironori.Fujii@sony.com>
>+
>+        [WebKit] Replace nonprefixed toImpl with WebKit::toImpl under WebKit/UIProcess/API/C
>+        https://bugs.webkit.org/show_bug.cgi?id=192450
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This change is a preparation for removing "using namespace WebKit" (Bug 192449).
>+
>+        * UIProcess/API/C/WKApplicationCacheManager.cpp:
>+        * UIProcess/API/C/WKAuthenticationChallenge.cpp:
>+        * UIProcess/API/C/WKAuthenticationDecisionListener.cpp:
>+        * UIProcess/API/C/WKBackForwardListItemRef.cpp:
>+        * UIProcess/API/C/WKBackForwardListRef.cpp:
>+        * UIProcess/API/C/WKContext.cpp:
>+        * UIProcess/API/C/WKContextConfigurationRef.cpp:
>+        * UIProcess/API/C/WKContextMenuListener.cpp:
>+        * UIProcess/API/C/WKCookieManager.cpp:
>+        * UIProcess/API/C/WKCredential.cpp:
>+        * UIProcess/API/C/WKDownload.cpp:
>+        * UIProcess/API/C/WKFormSubmissionListener.cpp:
>+        * UIProcess/API/C/WKFrame.cpp:
>+        * UIProcess/API/C/WKFrameHandleRef.cpp:
>+        * UIProcess/API/C/WKFrameInfoRef.cpp:
>+        * UIProcess/API/C/WKFramePolicyListener.cpp:
>+        * UIProcess/API/C/WKGeolocationManager.cpp:
>+        * UIProcess/API/C/WKGeolocationPermissionRequest.cpp:
>+        * UIProcess/API/C/WKGrammarDetail.cpp:
>+        * UIProcess/API/C/WKHitTestResult.cpp:
>+        * UIProcess/API/C/WKInspector.cpp:
>+        * UIProcess/API/C/WKKeyValueStorageManager.cpp:
>+        * UIProcess/API/C/WKMediaSessionFocusManager.cpp:
>+        * UIProcess/API/C/WKMediaSessionMetadata.cpp:
>+        * UIProcess/API/C/WKMockDisplay.cpp:
>+        * UIProcess/API/C/WKMockMediaDevice.cpp:
>+        * UIProcess/API/C/WKNavigationDataRef.cpp:
>+        * UIProcess/API/C/WKNavigationResponseRef.cpp:
>+        * UIProcess/API/C/WKNotification.cpp:
>+        * UIProcess/API/C/WKNotificationManager.cpp:
>+        * UIProcess/API/C/WKNotificationPermissionRequest.cpp:
>+        * UIProcess/API/C/WKOpenPanelParametersRef.cpp:
>+        * UIProcess/API/C/WKOpenPanelResultListener.cpp:
>+        * UIProcess/API/C/WKPage.cpp:
>+        * UIProcess/API/C/WKPageConfigurationRef.cpp:
>+        * UIProcess/API/C/WKPageGroup.cpp:
>+        * UIProcess/API/C/WKPreferences.cpp:
>+        * UIProcess/API/C/WKProtectionSpace.cpp:
>+        * UIProcess/API/C/WKResourceCacheManager.cpp:
>+        * UIProcess/API/C/WKTextChecker.cpp:
>+        * UIProcess/API/C/WKUserContentControllerRef.cpp:
>+        * UIProcess/API/C/WKUserMediaPermissionCheck.cpp:
>+        * UIProcess/API/C/WKUserMediaPermissionRequest.cpp:
>+        * UIProcess/API/C/WKUserScriptRef.cpp:
>+        * UIProcess/API/C/WKWebsitePolicies.cpp:
>+
> 2018-12-05  Youenn Fablet  <youenn@apple.com>
> 
>         Remove a document entry from NetworkMDNSRegister::m_services when document goes away
>diff --git a/Source/WebKit/UIProcess/API/C/WKApplicationCacheManager.cpp b/Source/WebKit/UIProcess/API/C/WKApplicationCacheManager.cpp
>index ee87ac19150606b4eb83a83dd7af3b27b027783c..1b0034a3baa72e05cc37a75141ec2bfd4e94f80a 100644
>--- a/Source/WebKit/UIProcess/API/C/WKApplicationCacheManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKApplicationCacheManager.cpp
>@@ -40,7 +40,7 @@ WKTypeID WKApplicationCacheManagerGetTypeID()
> 
> void WKApplicationCacheManagerGetApplicationCacheOrigins(WKApplicationCacheManagerRef applicationCacheManager, void* context, WKApplicationCacheManagerGetApplicationCacheOriginsFunction callback)
> {
>-    auto& websiteDataStore = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(applicationCacheManager))->websiteDataStore();
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(applicationCacheManager))->websiteDataStore();
>     websiteDataStore.fetchData(WebsiteDataType::OfflineWebApplicationCache, { }, [context, callback](auto dataRecords) {
>         Vector<RefPtr<API::Object>> securityOrigins;
>         for (const auto& dataRecord : dataRecords) {
>@@ -54,16 +54,16 @@ void WKApplicationCacheManagerGetApplicationCacheOrigins(WKApplicationCacheManag
> 
> void WKApplicationCacheManagerDeleteEntriesForOrigin(WKApplicationCacheManagerRef applicationCacheManager, WKSecurityOriginRef origin)
> {
>-    auto& websiteDataStore = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(applicationCacheManager))->websiteDataStore();
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(applicationCacheManager))->websiteDataStore();
> 
>     WebsiteDataRecord dataRecord;
>-    dataRecord.add(WebsiteDataType::OfflineWebApplicationCache, toImpl(origin)->securityOrigin().data());
>+    dataRecord.add(WebsiteDataType::OfflineWebApplicationCache, WebKit::toImpl(origin)->securityOrigin().data());
> 
>     websiteDataStore.removeData(WebsiteDataType::OfflineWebApplicationCache, { dataRecord }, [] { });
> }
> 
> void WKApplicationCacheManagerDeleteAllEntries(WKApplicationCacheManagerRef applicationCacheManager)
> {
>-    auto& websiteDataStore = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(applicationCacheManager))->websiteDataStore();
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(applicationCacheManager))->websiteDataStore();
>     websiteDataStore.removeData(WebsiteDataType::OfflineWebApplicationCache, -WallTime::infinity(), [] { });
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKAuthenticationChallenge.cpp b/Source/WebKit/UIProcess/API/C/WKAuthenticationChallenge.cpp
>index 73d5ff28b941e6a69396a7a9e9383c98caeb38fa..0461ec17a81cb46d98f0e2e087d8b72a0b1ef1ab 100644
>--- a/Source/WebKit/UIProcess/API/C/WKAuthenticationChallenge.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKAuthenticationChallenge.cpp
>@@ -42,20 +42,20 @@ WKTypeID WKAuthenticationChallengeGetTypeID()
> 
> WKAuthenticationDecisionListenerRef WKAuthenticationChallengeGetDecisionListener(WKAuthenticationChallengeRef challenge)
> {
>-    return toAPI(&toImpl(challenge)->listener());
>+    return toAPI(&WebKit::toImpl(challenge)->listener());
> }
> 
> WKProtectionSpaceRef WKAuthenticationChallengeGetProtectionSpace(WKAuthenticationChallengeRef challenge)
> {
>-    return toAPI(toImpl(challenge)->protectionSpace());
>+    return toAPI(WebKit::toImpl(challenge)->protectionSpace());
> }
> 
> WKCredentialRef WKAuthenticationChallengeGetProposedCredential(WKAuthenticationChallengeRef challenge)
> {
>-    return toAPI(toImpl(challenge)->proposedCredential());
>+    return toAPI(WebKit::toImpl(challenge)->proposedCredential());
> }
> 
> int WKAuthenticationChallengeGetPreviousFailureCount(WKAuthenticationChallengeRef challenge)
> {
>-    return toImpl(challenge)->core().previousFailureCount();
>+    return WebKit::toImpl(challenge)->core().previousFailureCount();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKAuthenticationDecisionListener.cpp b/Source/WebKit/UIProcess/API/C/WKAuthenticationDecisionListener.cpp
>index 0fa68de76167f80d327bdc214829a965faf2652b..e39226023eb071c19dcbb2d6ed17c87df64a64c1 100644
>--- a/Source/WebKit/UIProcess/API/C/WKAuthenticationDecisionListener.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKAuthenticationDecisionListener.cpp
>@@ -40,15 +40,15 @@ WKTypeID WKAuthenticationDecisionListenerGetTypeID()
> 
> void WKAuthenticationDecisionListenerUseCredential(WKAuthenticationDecisionListenerRef authenticationListener, WKCredentialRef credential)
> {
>-    toImpl(authenticationListener)->completeChallenge(AuthenticationChallengeDisposition::UseCredential, credential ? toImpl(credential)->credential() : WebCore::Credential());
>+    WebKit::toImpl(authenticationListener)->completeChallenge(AuthenticationChallengeDisposition::UseCredential, credential ? WebKit::toImpl(credential)->credential() : WebCore::Credential());
> }
> 
> void WKAuthenticationDecisionListenerCancel(WKAuthenticationDecisionListenerRef authenticationListener)
> {
>-    toImpl(authenticationListener)->completeChallenge(AuthenticationChallengeDisposition::Cancel);
>+    WebKit::toImpl(authenticationListener)->completeChallenge(AuthenticationChallengeDisposition::Cancel);
> }
> 
> void WKAuthenticationDecisionListenerRejectProtectionSpaceAndContinue(WKAuthenticationDecisionListenerRef authenticationListener)
> {
>-    toImpl(authenticationListener)->completeChallenge(AuthenticationChallengeDisposition::RejectProtectionSpaceAndContinue);
>+    WebKit::toImpl(authenticationListener)->completeChallenge(AuthenticationChallengeDisposition::RejectProtectionSpaceAndContinue);
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKBackForwardListItemRef.cpp b/Source/WebKit/UIProcess/API/C/WKBackForwardListItemRef.cpp
>index fea7fb941ff75226a029e61253aaeb01d9715014..c1b73de74db2fb25e93f22b796530de579ae7a90 100644
>--- a/Source/WebKit/UIProcess/API/C/WKBackForwardListItemRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKBackForwardListItemRef.cpp
>@@ -38,15 +38,15 @@ WKTypeID WKBackForwardListItemGetTypeID()
> 
> WKURLRef WKBackForwardListItemCopyURL(WKBackForwardListItemRef itemRef)
> {
>-    return toCopiedURLAPI(toImpl(itemRef)->url());
>+    return toCopiedURLAPI(WebKit::toImpl(itemRef)->url());
> }
> 
> WKStringRef WKBackForwardListItemCopyTitle(WKBackForwardListItemRef itemRef)
> {
>-    return toCopiedAPI(toImpl(itemRef)->title());
>+    return toCopiedAPI(WebKit::toImpl(itemRef)->title());
> }
> 
> WKURLRef WKBackForwardListItemCopyOriginalURL(WKBackForwardListItemRef itemRef)
> {
>-    return toCopiedURLAPI(toImpl(itemRef)->originalURL());
>+    return toCopiedURLAPI(WebKit::toImpl(itemRef)->originalURL());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKBackForwardListRef.cpp b/Source/WebKit/UIProcess/API/C/WKBackForwardListRef.cpp
>index 4be7fc3698ca5fe6f203aa25806a1b6d2acb8ee5..fd68b09c99bd4bfeea120b390f77ab4109f6bd0d 100644
>--- a/Source/WebKit/UIProcess/API/C/WKBackForwardListRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKBackForwardListRef.cpp
>@@ -39,45 +39,45 @@ WKTypeID WKBackForwardListGetTypeID()
> 
> WKBackForwardListItemRef WKBackForwardListGetCurrentItem(WKBackForwardListRef listRef)
> {
>-    return toAPI(toImpl(listRef)->currentItem());
>+    return toAPI(WebKit::toImpl(listRef)->currentItem());
> }
> 
> WKBackForwardListItemRef WKBackForwardListGetBackItem(WKBackForwardListRef listRef)
> {
>-    return toAPI(toImpl(listRef)->backItem());
>+    return toAPI(WebKit::toImpl(listRef)->backItem());
> }
> 
> WKBackForwardListItemRef WKBackForwardListGetForwardItem(WKBackForwardListRef listRef)
> {
>-    return toAPI(toImpl(listRef)->forwardItem());
>+    return toAPI(WebKit::toImpl(listRef)->forwardItem());
> }
> 
> WKBackForwardListItemRef WKBackForwardListGetItemAtIndex(WKBackForwardListRef listRef, int index)
> {
>-    return toAPI(toImpl(listRef)->itemAtIndex(index));
>+    return toAPI(WebKit::toImpl(listRef)->itemAtIndex(index));
> }
> 
> void WKBackForwardListClear(WKBackForwardListRef listRef)
> {
>-    toImpl(listRef)->clear();
>+    WebKit::toImpl(listRef)->clear();
> }
> 
> unsigned WKBackForwardListGetBackListCount(WKBackForwardListRef listRef)
> {
>-    return toImpl(listRef)->backListCount();
>+    return WebKit::toImpl(listRef)->backListCount();
> }
> 
> unsigned WKBackForwardListGetForwardListCount(WKBackForwardListRef listRef)
> {
>-    return toImpl(listRef)->forwardListCount();
>+    return WebKit::toImpl(listRef)->forwardListCount();
> }
> 
> WKArrayRef WKBackForwardListCopyBackListWithLimit(WKBackForwardListRef listRef, unsigned limit)
> {
>-    return toAPI(&toImpl(listRef)->backListAsAPIArrayWithLimit(limit).leakRef());
>+    return toAPI(&WebKit::toImpl(listRef)->backListAsAPIArrayWithLimit(limit).leakRef());
> }
> 
> WKArrayRef WKBackForwardListCopyForwardListWithLimit(WKBackForwardListRef listRef, unsigned limit)
> {
>-    return toAPI(&toImpl(listRef)->forwardListAsAPIArrayWithLimit(limit).leakRef());
>+    return toAPI(&WebKit::toImpl(listRef)->forwardListAsAPIArrayWithLimit(limit).leakRef());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKContext.cpp b/Source/WebKit/UIProcess/API/C/WKContext.cpp
>index 87016ab758ebc12d398dffd3c05b8f21ab505268..4b9d75fc8a1119f08fecfcd6ad35b27060db3b63 100644
>--- a/Source/WebKit/UIProcess/API/C/WKContext.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKContext.cpp
>@@ -84,17 +84,17 @@ WKContextRef WKContextCreateWithInjectedBundlePath(WKStringRef pathRef)
> 
> WKContextRef WKContextCreateWithConfiguration(WKContextConfigurationRef configuration)
> {
>-    return toAPI(&WebProcessPool::create(*toImpl(configuration)).leakRef());
>+    return toAPI(&WebProcessPool::create(*WebKit::toImpl(configuration)).leakRef());
> }
> 
> void WKContextSetClient(WKContextRef contextRef, const WKContextClientBase* wkClient)
> {
>-    toImpl(contextRef)->initializeClient(wkClient);
>+    WebKit::toImpl(contextRef)->initializeClient(wkClient);
> }
> 
> void WKContextSetInjectedBundleClient(WKContextRef contextRef, const WKContextInjectedBundleClientBase* wkClient)
> {
>-    toImpl(contextRef)->setInjectedBundleClient(std::make_unique<WebContextInjectedBundleClient>(wkClient));
>+    WebKit::toImpl(contextRef)->setInjectedBundleClient(std::make_unique<WebContextInjectedBundleClient>(wkClient));
> }
> 
> void WKContextSetHistoryClient(WKContextRef contextRef, const WKContextHistoryClientBase* wkClient)
>@@ -154,7 +154,7 @@ void WKContextSetHistoryClient(WKContextRef contextRef, const WKContextHistoryCl
>         }
>     };
> 
>-    WebProcessPool& processPool = *toImpl(contextRef);
>+    WebProcessPool& processPool = *WebKit::toImpl(contextRef);
>     processPool.setHistoryClient(std::make_unique<HistoryClient>(wkClient));
> 
>     bool addsVisitedLinks = processPool.historyClient().addsVisitedLinks();
>@@ -267,32 +267,32 @@ void WKContextSetDownloadClient(WKContextRef contextRef, const WKContextDownload
> 
>     };
> 
>-    toImpl(contextRef)->setDownloadClient(std::make_unique<DownloadClient>(wkClient));
>+    WebKit::toImpl(contextRef)->setDownloadClient(std::make_unique<DownloadClient>(wkClient));
> }
> 
> void WKContextSetConnectionClient(WKContextRef contextRef, const WKContextConnectionClientBase* wkClient)
> {
>-    toImpl(contextRef)->initializeConnectionClient(wkClient);
>+    WebKit::toImpl(contextRef)->initializeConnectionClient(wkClient);
> }
> 
> WKDownloadRef WKContextDownloadURLRequest(WKContextRef contextRef, WKURLRequestRef requestRef)
> {
>-    return toAPI(toImpl(contextRef)->download(0, toImpl(requestRef)->resourceRequest()));
>+    return toAPI(WebKit::toImpl(contextRef)->download(0, WebKit::toImpl(requestRef)->resourceRequest()));
> }
> 
> WKDownloadRef WKContextResumeDownload(WKContextRef contextRef, WKDataRef resumeData, WKStringRef path)
> {
>-    return toAPI(toImpl(contextRef)->resumeDownload(toImpl(resumeData), toWTFString(path)));
>+    return toAPI(WebKit::toImpl(contextRef)->resumeDownload(WebKit::toImpl(resumeData), toWTFString(path)));
> }
> 
> void WKContextSetInitializationUserDataForInjectedBundle(WKContextRef contextRef,  WKTypeRef userDataRef)
> {
>-    toImpl(contextRef)->setInjectedBundleInitializationUserData(toImpl(userDataRef));
>+    WebKit::toImpl(contextRef)->setInjectedBundleInitializationUserData(WebKit::toImpl(userDataRef));
> }
> 
> void WKContextPostMessageToInjectedBundle(WKContextRef contextRef, WKStringRef messageNameRef, WKTypeRef messageBodyRef)
> {
>-    toImpl(contextRef)->postMessageToInjectedBundle(toImpl(messageNameRef)->string(), toImpl(messageBodyRef));
>+    WebKit::toImpl(contextRef)->postMessageToInjectedBundle(WebKit::toImpl(messageNameRef)->string(), WebKit::toImpl(messageBodyRef));
> }
> 
> void WKContextGetGlobalStatistics(WKContextStatistics* statistics)
>@@ -306,52 +306,52 @@ void WKContextGetGlobalStatistics(WKContextStatistics* statistics)
> 
> void WKContextAddVisitedLink(WKContextRef contextRef, WKStringRef visitedURL)
> {
>-    String visitedURLString = toImpl(visitedURL)->string();
>+    String visitedURLString = WebKit::toImpl(visitedURL)->string();
>     if (visitedURLString.isEmpty())
>         return;
> 
>-    toImpl(contextRef)->visitedLinkStore().addVisitedLinkHash(computeSharedStringHash(visitedURLString));
>+    WebKit::toImpl(contextRef)->visitedLinkStore().addVisitedLinkHash(computeSharedStringHash(visitedURLString));
> }
> 
> void WKContextClearVisitedLinks(WKContextRef contextRef)
> {
>-    toImpl(contextRef)->visitedLinkStore().removeAll();
>+    WebKit::toImpl(contextRef)->visitedLinkStore().removeAll();
> }
> 
> void WKContextSetCacheModel(WKContextRef contextRef, WKCacheModel cacheModel)
> {
>-    toImpl(contextRef)->setCacheModel(toCacheModel(cacheModel));
>+    WebKit::toImpl(contextRef)->setCacheModel(toCacheModel(cacheModel));
> }
> 
> WKCacheModel WKContextGetCacheModel(WKContextRef contextRef)
> {
>-    return toAPI(toImpl(contextRef)->cacheModel());
>+    return toAPI(WebKit::toImpl(contextRef)->cacheModel());
> }
> 
> void WKContextSetMaximumNumberOfProcesses(WKContextRef contextRef, unsigned numberOfProcesses)
> {
>-    toImpl(contextRef)->setMaximumNumberOfProcesses(numberOfProcesses);
>+    WebKit::toImpl(contextRef)->setMaximumNumberOfProcesses(numberOfProcesses);
> }
> 
> unsigned WKContextGetMaximumNumberOfProcesses(WKContextRef contextRef)
> {
>-    return toImpl(contextRef)->maximumNumberOfProcesses();
>+    return WebKit::toImpl(contextRef)->maximumNumberOfProcesses();
> }
> 
> void WKContextSetAlwaysUsesComplexTextCodePath(WKContextRef contextRef, bool alwaysUseComplexTextCodePath)
> {
>-    toImpl(contextRef)->setAlwaysUsesComplexTextCodePath(alwaysUseComplexTextCodePath);
>+    WebKit::toImpl(contextRef)->setAlwaysUsesComplexTextCodePath(alwaysUseComplexTextCodePath);
> }
> 
> void WKContextSetShouldUseFontSmoothing(WKContextRef contextRef, bool useFontSmoothing)
> {
>-    toImpl(contextRef)->setShouldUseFontSmoothing(useFontSmoothing);
>+    WebKit::toImpl(contextRef)->setShouldUseFontSmoothing(useFontSmoothing);
> }
> 
> void WKContextSetAdditionalPluginsDirectory(WKContextRef contextRef, WKStringRef pluginsDirectory)
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    toImpl(contextRef)->setAdditionalPluginsDirectory(toImpl(pluginsDirectory)->string());
>+    WebKit::toImpl(contextRef)->setAdditionalPluginsDirectory(WebKit::toImpl(pluginsDirectory)->string());
> #else
>     UNUSED_PARAM(contextRef);
>     UNUSED_PARAM(pluginsDirectory);
>@@ -361,7 +361,7 @@ void WKContextSetAdditionalPluginsDirectory(WKContextRef contextRef, WKStringRef
> void WKContextRefreshPlugIns(WKContextRef context)
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    toImpl(context)->refreshPlugins();
>+    WebKit::toImpl(context)->refreshPlugins();
> #else
>     UNUSED_PARAM(context);
> #endif
>@@ -369,70 +369,70 @@ void WKContextRefreshPlugIns(WKContextRef context)
> 
> void WKContextRegisterURLSchemeAsEmptyDocument(WKContextRef contextRef, WKStringRef urlScheme)
> {
>-    toImpl(contextRef)->registerURLSchemeAsEmptyDocument(toImpl(urlScheme)->string());
>+    WebKit::toImpl(contextRef)->registerURLSchemeAsEmptyDocument(WebKit::toImpl(urlScheme)->string());
> }
> 
> void WKContextRegisterURLSchemeAsSecure(WKContextRef contextRef, WKStringRef urlScheme)
> {
>-    toImpl(contextRef)->registerURLSchemeAsSecure(toImpl(urlScheme)->string());
>+    WebKit::toImpl(contextRef)->registerURLSchemeAsSecure(WebKit::toImpl(urlScheme)->string());
> }
> 
> void WKContextRegisterURLSchemeAsBypassingContentSecurityPolicy(WKContextRef contextRef, WKStringRef urlScheme)
> {
>-    toImpl(contextRef)->registerURLSchemeAsBypassingContentSecurityPolicy(toImpl(urlScheme)->string());
>+    WebKit::toImpl(contextRef)->registerURLSchemeAsBypassingContentSecurityPolicy(WebKit::toImpl(urlScheme)->string());
> }
> 
> void WKContextRegisterURLSchemeAsCachePartitioned(WKContextRef contextRef, WKStringRef urlScheme)
> {
>-    toImpl(contextRef)->registerURLSchemeAsCachePartitioned(toImpl(urlScheme)->string());
>+    WebKit::toImpl(contextRef)->registerURLSchemeAsCachePartitioned(WebKit::toImpl(urlScheme)->string());
> }
> 
> void WKContextRegisterURLSchemeAsCanDisplayOnlyIfCanRequest(WKContextRef contextRef, WKStringRef urlScheme)
> {
>-    toImpl(contextRef)->registerURLSchemeAsCanDisplayOnlyIfCanRequest(toImpl(urlScheme)->string());
>+    WebKit::toImpl(contextRef)->registerURLSchemeAsCanDisplayOnlyIfCanRequest(WebKit::toImpl(urlScheme)->string());
> }
> 
> void WKContextSetDomainRelaxationForbiddenForURLScheme(WKContextRef contextRef, WKStringRef urlScheme)
> {
>-    toImpl(contextRef)->setDomainRelaxationForbiddenForURLScheme(toImpl(urlScheme)->string());
>+    WebKit::toImpl(contextRef)->setDomainRelaxationForbiddenForURLScheme(WebKit::toImpl(urlScheme)->string());
> }
> 
> void WKContextSetCanHandleHTTPSServerTrustEvaluation(WKContextRef contextRef, bool value)
> {
>-    toImpl(contextRef)->setCanHandleHTTPSServerTrustEvaluation(value);
>+    WebKit::toImpl(contextRef)->setCanHandleHTTPSServerTrustEvaluation(value);
> }
> 
> void WKContextSetPrewarmsProcessesAutomatically(WKContextRef contextRef, bool value)
> {
>-    toImpl(contextRef)->configuration().setIsAutomaticProcessWarmingEnabled(value);
>+    WebKit::toImpl(contextRef)->configuration().setIsAutomaticProcessWarmingEnabled(value);
> }
> 
> void WKContextSetCustomWebContentServiceBundleIdentifier(WKContextRef contextRef, WKStringRef name)
> {
>-    toImpl(contextRef)->setCustomWebContentServiceBundleIdentifier(toImpl(name)->string());
>+    WebKit::toImpl(contextRef)->setCustomWebContentServiceBundleIdentifier(WebKit::toImpl(name)->string());
> }
> 
> void WKContextSetDiskCacheSpeculativeValidationEnabled(WKContextRef contextRef, bool value)
> {
>-    toImpl(contextRef)->configuration().setDiskCacheSpeculativeValidationEnabled(value);
>+    WebKit::toImpl(contextRef)->configuration().setDiskCacheSpeculativeValidationEnabled(value);
> }
> 
> void WKContextPreconnectToServer(WKContextRef contextRef, WKURLRef serverURLRef)
> {
>-    toImpl(contextRef)->preconnectToServer(URL(URL(), toWTFString(serverURLRef)));
>+    WebKit::toImpl(contextRef)->preconnectToServer(URL(URL(), toWTFString(serverURLRef)));
> }
> 
> WKCookieManagerRef WKContextGetCookieManager(WKContextRef contextRef)
> {
>-    return toAPI(toImpl(contextRef)->supplement<WebCookieManagerProxy>());
>+    return toAPI(WebKit::toImpl(contextRef)->supplement<WebCookieManagerProxy>());
> }
> 
> WKWebsiteDataStoreRef WKContextGetWebsiteDataStore(WKContextRef context)
> {
>-    auto* dataStore = toImpl(context)->websiteDataStore();
>+    auto* dataStore = WebKit::toImpl(context)->websiteDataStore();
>     if (!dataStore) {
>         auto defaultDataStore = API::WebsiteDataStore::defaultDataStore();
>-        toImpl(context)->setPrimaryDataStore(defaultDataStore.get());
>+        WebKit::toImpl(context)->setPrimaryDataStore(defaultDataStore.get());
>         dataStore = defaultDataStore.ptr();
>     }
> 
>@@ -446,7 +446,7 @@ WKApplicationCacheManagerRef WKContextGetApplicationCacheManager(WKContextRef co
> 
> WKGeolocationManagerRef WKContextGetGeolocationManager(WKContextRef contextRef)
> {
>-    return toAPI(toImpl(contextRef)->supplement<WebGeolocationManagerProxy>());
>+    return toAPI(WebKit::toImpl(contextRef)->supplement<WebGeolocationManagerProxy>());
> }
> 
> WKIconDatabaseRef WKContextGetIconDatabase(WKContextRef)
>@@ -462,7 +462,7 @@ WKKeyValueStorageManagerRef WKContextGetKeyValueStorageManager(WKContextRef cont
> WKMediaSessionFocusManagerRef WKContextGetMediaSessionFocusManager(WKContextRef context)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toAPI(toImpl(context)->supplement<WebMediaSessionFocusManager>());
>+    return toAPI(WebKit::toImpl(context)->supplement<WebMediaSessionFocusManager>());
> #else
>     UNUSED_PARAM(context);
>     return nullptr;
>@@ -471,7 +471,7 @@ WKMediaSessionFocusManagerRef WKContextGetMediaSessionFocusManager(WKContextRef
> 
> WKNotificationManagerRef WKContextGetNotificationManager(WKContextRef contextRef)
> {
>-    return toAPI(toImpl(contextRef)->supplement<WebNotificationManagerProxy>());
>+    return toAPI(WebKit::toImpl(contextRef)->supplement<WebNotificationManagerProxy>());
> }
> 
> WKResourceCacheManagerRef WKContextGetResourceCacheManager(WKContextRef context)
>@@ -481,12 +481,12 @@ WKResourceCacheManagerRef WKContextGetResourceCacheManager(WKContextRef context)
> 
> void WKContextStartMemorySampler(WKContextRef contextRef, WKDoubleRef interval)
> {
>-    toImpl(contextRef)->startMemorySampler(toImpl(interval)->value());
>+    WebKit::toImpl(contextRef)->startMemorySampler(WebKit::toImpl(interval)->value());
> }
> 
> void WKContextStopMemorySampler(WKContextRef contextRef)
> {
>-    toImpl(contextRef)->stopMemorySampler();
>+    WebKit::toImpl(contextRef)->stopMemorySampler();
> }
> 
> void WKContextSetIconDatabasePath(WKContextRef, WKStringRef)
>@@ -495,105 +495,105 @@ void WKContextSetIconDatabasePath(WKContextRef, WKStringRef)
> 
> void WKContextAllowSpecificHTTPSCertificateForHost(WKContextRef contextRef, WKCertificateInfoRef certificateRef, WKStringRef hostRef)
> {
>-    toImpl(contextRef)->allowSpecificHTTPSCertificateForHost(toImpl(certificateRef), toImpl(hostRef)->string());
>+    WebKit::toImpl(contextRef)->allowSpecificHTTPSCertificateForHost(WebKit::toImpl(certificateRef), WebKit::toImpl(hostRef)->string());
> }
> 
> void WKContextDisableProcessTermination(WKContextRef contextRef)
> {
>-    toImpl(contextRef)->disableProcessTermination();
>+    WebKit::toImpl(contextRef)->disableProcessTermination();
> }
> 
> void WKContextEnableProcessTermination(WKContextRef contextRef)
> {
>-    toImpl(contextRef)->enableProcessTermination();
>+    WebKit::toImpl(contextRef)->enableProcessTermination();
> }
> 
> void WKContextSetHTTPPipeliningEnabled(WKContextRef contextRef, bool enabled)
> {
>-    toImpl(contextRef)->setHTTPPipeliningEnabled(enabled);
>+    WebKit::toImpl(contextRef)->setHTTPPipeliningEnabled(enabled);
> }
> 
> void WKContextWarmInitialProcess(WKContextRef contextRef)
> {
>-    toImpl(contextRef)->prewarmProcess(WebProcessPool::MayCreateDefaultDataStore::Yes);
>+    WebKit::toImpl(contextRef)->prewarmProcess(WebProcessPool::MayCreateDefaultDataStore::Yes);
> }
> 
> void WKContextGetStatistics(WKContextRef contextRef, void* context, WKContextGetStatisticsFunction callback)
> {
>-    toImpl(contextRef)->getStatistics(0xFFFFFFFF, toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(contextRef)->getStatistics(0xFFFFFFFF, toGenericCallbackFunction(context, callback));
> }
> 
> void WKContextGetStatisticsWithOptions(WKContextRef contextRef, WKStatisticsOptions optionsMask, void* context, WKContextGetStatisticsFunction callback)
> {
>-    toImpl(contextRef)->getStatistics(optionsMask, toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(contextRef)->getStatistics(optionsMask, toGenericCallbackFunction(context, callback));
> }
> 
> bool WKContextJavaScriptConfigurationFileEnabled(WKContextRef contextRef)
> {
>-    return toImpl(contextRef)->javaScriptConfigurationFileEnabled();
>+    return WebKit::toImpl(contextRef)->javaScriptConfigurationFileEnabled();
> }
> 
> void WKContextSetJavaScriptConfigurationFileEnabled(WKContextRef contextRef, bool enable)
> {
>-    toImpl(contextRef)->setJavaScriptConfigurationFileEnabled(enable);
>+    WebKit::toImpl(contextRef)->setJavaScriptConfigurationFileEnabled(enable);
> }
> 
> void WKContextGarbageCollectJavaScriptObjects(WKContextRef contextRef)
> {
>-    toImpl(contextRef)->garbageCollectJavaScriptObjects();
>+    WebKit::toImpl(contextRef)->garbageCollectJavaScriptObjects();
> }
> 
> void WKContextSetJavaScriptGarbageCollectorTimerEnabled(WKContextRef contextRef, bool enable)
> {
>-    toImpl(contextRef)->setJavaScriptGarbageCollectorTimerEnabled(enable);
>+    WebKit::toImpl(contextRef)->setJavaScriptGarbageCollectorTimerEnabled(enable);
> }
> 
> void WKContextUseTestingNetworkSession(WKContextRef context)
> {
>-    toImpl(context)->useTestingNetworkSession();
>+    WebKit::toImpl(context)->useTestingNetworkSession();
> }
> 
> void WKContextSetAllowsAnySSLCertificateForWebSocketTesting(WKContextRef context, bool allows)
> {
>-    toImpl(context)->setAllowsAnySSLCertificateForWebSocket(allows);
>+    WebKit::toImpl(context)->setAllowsAnySSLCertificateForWebSocket(allows);
> }
> 
> void WKContextSetAllowsAnySSLCertificateForServiceWorkerTesting(WKContextRef context, bool allows)
> {
> #if ENABLE(SERVICE_WORKER)
>-    toImpl(context)->setAllowsAnySSLCertificateForServiceWorker(allows);
>+    WebKit::toImpl(context)->setAllowsAnySSLCertificateForServiceWorker(allows);
> #endif
> }
> 
> void WKContextClearCachedCredentials(WKContextRef context)
> {
>-    toImpl(context)->clearCachedCredentials();
>+    WebKit::toImpl(context)->clearCachedCredentials();
> }
> 
> WKDictionaryRef WKContextCopyPlugInAutoStartOriginHashes(WKContextRef contextRef)
> {
>-    return toAPI(&toImpl(contextRef)->plugInAutoStartOriginHashes().leakRef());
>+    return toAPI(&WebKit::toImpl(contextRef)->plugInAutoStartOriginHashes().leakRef());
> }
> 
> void WKContextSetPlugInAutoStartOriginHashes(WKContextRef contextRef, WKDictionaryRef dictionaryRef)
> {
>     if (!dictionaryRef)
>         return;
>-    toImpl(contextRef)->setPlugInAutoStartOriginHashes(*toImpl(dictionaryRef));
>+    WebKit::toImpl(contextRef)->setPlugInAutoStartOriginHashes(*WebKit::toImpl(dictionaryRef));
> }
> 
> void WKContextSetPlugInAutoStartOriginsFilteringOutEntriesAddedAfterTime(WKContextRef contextRef, WKDictionaryRef dictionaryRef, double time)
> {
>     if (!dictionaryRef)
>         return;
>-    toImpl(contextRef)->setPlugInAutoStartOriginsFilteringOutEntriesAddedAfterTime(*toImpl(dictionaryRef), WallTime::fromRawSeconds(time));
>+    WebKit::toImpl(contextRef)->setPlugInAutoStartOriginsFilteringOutEntriesAddedAfterTime(*WebKit::toImpl(dictionaryRef), WallTime::fromRawSeconds(time));
> }
> 
> void WKContextSetPlugInAutoStartOrigins(WKContextRef contextRef, WKArrayRef arrayRef)
> {
>     if (!arrayRef)
>         return;
>-    toImpl(contextRef)->setPlugInAutoStartOrigins(*toImpl(arrayRef));
>+    WebKit::toImpl(contextRef)->setPlugInAutoStartOrigins(*WebKit::toImpl(arrayRef));
> }
> 
> void WKContextSetInvalidMessageFunction(WKContextInvalidMessageFunction invalidMessageFunction)
>@@ -603,27 +603,27 @@ void WKContextSetInvalidMessageFunction(WKContextInvalidMessageFunction invalidM
> 
> void WKContextSetMemoryCacheDisabled(WKContextRef contextRef, bool disabled)
> {
>-    toImpl(contextRef)->setMemoryCacheDisabled(disabled);
>+    WebKit::toImpl(contextRef)->setMemoryCacheDisabled(disabled);
> }
> 
> void WKContextSetFontWhitelist(WKContextRef contextRef, WKArrayRef arrayRef)
> {
>-    toImpl(contextRef)->setFontWhitelist(toImpl(arrayRef));
>+    WebKit::toImpl(contextRef)->setFontWhitelist(WebKit::toImpl(arrayRef));
> }
> 
> void WKContextTerminateNetworkProcess(WKContextRef context)
> {
>-    toImpl(context)->terminateNetworkProcess();
>+    WebKit::toImpl(context)->terminateNetworkProcess();
> }
> 
> void WKContextTerminateServiceWorkerProcess(WKContextRef context)
> {
>-    toImpl(context)->terminateServiceWorkerProcesses();
>+    WebKit::toImpl(context)->terminateServiceWorkerProcesses();
> }
> 
> ProcessID WKContextGetNetworkProcessIdentifier(WKContextRef contextRef)
> {
>-    return toImpl(contextRef)->networkProcessIdentifier();
>+    return WebKit::toImpl(contextRef)->networkProcessIdentifier();
> }
> 
> void WKContextAddSupportedPlugin(WKContextRef contextRef, WKStringRef domainRef, WKStringRef nameRef, WKArrayRef mimeTypesRef, WKArrayRef extensionsRef)
>@@ -639,18 +639,18 @@ void WKContextAddSupportedPlugin(WKContextRef contextRef, WKStringRef domainRef,
>     for (size_t i = 0; i < count; ++i)
>         extensions.add(toWTFString(static_cast<WKStringRef>(WKArrayGetItemAtIndex(extensionsRef, i))));
> 
>-    toImpl(contextRef)->addSupportedPlugin(toWTFString(domainRef), toWTFString(nameRef), WTFMove(mimeTypes), WTFMove(extensions));
>+    WebKit::toImpl(contextRef)->addSupportedPlugin(toWTFString(domainRef), toWTFString(nameRef), WTFMove(mimeTypes), WTFMove(extensions));
> #endif
> }
> 
> void WKContextClearSupportedPlugins(WKContextRef contextRef)
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    toImpl(contextRef)->clearSupportedPlugins();
>+    WebKit::toImpl(contextRef)->clearSupportedPlugins();
> #endif
> }
> 
> void WKContextSetIDBPerOriginQuota(WKContextRef contextRef, uint64_t quota)
> {
>-    toImpl(contextRef)->setIDBPerOriginQuota(quota);
>+    WebKit::toImpl(contextRef)->setIDBPerOriginQuota(quota);
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKContextConfigurationRef.cpp b/Source/WebKit/UIProcess/API/C/WKContextConfigurationRef.cpp
>index 86d41299dfaab3d64e7c41e060c02f661cd1c37e..3c25b763afe5091ca73c9890ff9d54e8ee088bdd 100644
>--- a/Source/WebKit/UIProcess/API/C/WKContextConfigurationRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKContextConfigurationRef.cpp
>@@ -50,152 +50,152 @@ WKContextConfigurationRef WKContextConfigurationCreateWithLegacyOptions()
> 
> WKStringRef WKContextConfigurationCopyDiskCacheDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->diskCacheDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->diskCacheDirectory());
> }
> 
> void WKContextConfigurationSetDiskCacheDirectory(WKContextConfigurationRef configuration, WKStringRef diskCacheDirectory)
> {
>-    toImpl(configuration)->setDiskCacheDirectory(toImpl(diskCacheDirectory)->string());
>+    WebKit::toImpl(configuration)->setDiskCacheDirectory(WebKit::toImpl(diskCacheDirectory)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyApplicationCacheDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->applicationCacheDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->applicationCacheDirectory());
> }
> 
> void WKContextConfigurationSetApplicationCacheDirectory(WKContextConfigurationRef configuration, WKStringRef applicationCacheDirectory)
> {
>-    toImpl(configuration)->setApplicationCacheDirectory(toImpl(applicationCacheDirectory)->string());
>+    WebKit::toImpl(configuration)->setApplicationCacheDirectory(WebKit::toImpl(applicationCacheDirectory)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyIndexedDBDatabaseDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->indexedDBDatabaseDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->indexedDBDatabaseDirectory());
> }
> 
> void WKContextConfigurationSetIndexedDBDatabaseDirectory(WKContextConfigurationRef configuration, WKStringRef indexedDBDatabaseDirectory)
> {
>-    toImpl(configuration)->setIndexedDBDatabaseDirectory(toImpl(indexedDBDatabaseDirectory)->string());
>+    WebKit::toImpl(configuration)->setIndexedDBDatabaseDirectory(WebKit::toImpl(indexedDBDatabaseDirectory)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyInjectedBundlePath(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->injectedBundlePath());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->injectedBundlePath());
> }
> 
> void WKContextConfigurationSetInjectedBundlePath(WKContextConfigurationRef configuration, WKStringRef injectedBundlePath)
> {
>-    toImpl(configuration)->setInjectedBundlePath(toImpl(injectedBundlePath)->string());
>+    WebKit::toImpl(configuration)->setInjectedBundlePath(WebKit::toImpl(injectedBundlePath)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyLocalStorageDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->localStorageDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->localStorageDirectory());
> }
> 
> void WKContextConfigurationSetLocalStorageDirectory(WKContextConfigurationRef configuration, WKStringRef localStorageDirectory)
> {
>-    toImpl(configuration)->setLocalStorageDirectory(toImpl(localStorageDirectory)->string());
>+    WebKit::toImpl(configuration)->setLocalStorageDirectory(WebKit::toImpl(localStorageDirectory)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyWebSQLDatabaseDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->webSQLDatabaseDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->webSQLDatabaseDirectory());
> }
> 
> void WKContextConfigurationSetWebSQLDatabaseDirectory(WKContextConfigurationRef configuration, WKStringRef webSQLDatabaseDirectory)
> {
>-    toImpl(configuration)->setWebSQLDatabaseDirectory(toImpl(webSQLDatabaseDirectory)->string());
>+    WebKit::toImpl(configuration)->setWebSQLDatabaseDirectory(WebKit::toImpl(webSQLDatabaseDirectory)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyMediaKeysStorageDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->mediaKeysStorageDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->mediaKeysStorageDirectory());
> }
> 
> void WKContextConfigurationSetMediaKeysStorageDirectory(WKContextConfigurationRef configuration, WKStringRef mediaKeysStorageDirectory)
> {
>-    toImpl(configuration)->setMediaKeysStorageDirectory(toImpl(mediaKeysStorageDirectory)->string());
>+    WebKit::toImpl(configuration)->setMediaKeysStorageDirectory(WebKit::toImpl(mediaKeysStorageDirectory)->string());
> }
> 
> WKStringRef WKContextConfigurationCopyResourceLoadStatisticsDirectory(WKContextConfigurationRef configuration)
> {
>-    return toCopiedAPI(toImpl(configuration)->resourceLoadStatisticsDirectory());
>+    return toCopiedAPI(WebKit::toImpl(configuration)->resourceLoadStatisticsDirectory());
> }
> 
> void WKContextConfigurationSetResourceLoadStatisticsDirectory(WKContextConfigurationRef configuration, WKStringRef resourceLoadStatisticsDirectory)
> {
>-    toImpl(configuration)->setResourceLoadStatisticsDirectory(toImpl(resourceLoadStatisticsDirectory)->string());
>+    WebKit::toImpl(configuration)->setResourceLoadStatisticsDirectory(WebKit::toImpl(resourceLoadStatisticsDirectory)->string());
> }
> 
> bool WKContextConfigurationFullySynchronousModeIsAllowedForTesting(WKContextConfigurationRef configuration)
> {
>-    return toImpl(configuration)->fullySynchronousModeIsAllowedForTesting();
>+    return WebKit::toImpl(configuration)->fullySynchronousModeIsAllowedForTesting();
> }
> 
> void WKContextConfigurationSetFullySynchronousModeIsAllowedForTesting(WKContextConfigurationRef configuration, bool allowed)
> {
>-    toImpl(configuration)->setFullySynchronousModeIsAllowedForTesting(allowed);
>+    WebKit::toImpl(configuration)->setFullySynchronousModeIsAllowedForTesting(allowed);
> }
> 
> WKArrayRef WKContextConfigurationCopyOverrideLanguages(WKContextConfigurationRef configuration)
> {
>-    return toAPI(&API::Array::createStringArray(toImpl(configuration)->overrideLanguages()).leakRef());
>+    return toAPI(&API::Array::createStringArray(WebKit::toImpl(configuration)->overrideLanguages()).leakRef());
> }
> 
> void WKContextConfigurationSetOverrideLanguages(WKContextConfigurationRef configuration, WKArrayRef overrideLanguages)
> {
>-    toImpl(configuration)->setOverrideLanguages(toImpl(overrideLanguages)->toStringVector());
>+    WebKit::toImpl(configuration)->setOverrideLanguages(WebKit::toImpl(overrideLanguages)->toStringVector());
> }
> 
> bool WKContextConfigurationShouldCaptureAudioInUIProcess(WKContextConfigurationRef configuration)
> {
>-    return toImpl(configuration)->shouldCaptureAudioInUIProcess();
>+    return WebKit::toImpl(configuration)->shouldCaptureAudioInUIProcess();
> }
> 
> void WKContextConfigurationSetShouldCaptureAudioInUIProcess(WKContextConfigurationRef configuration, bool should)
> {
>-    toImpl(configuration)->setShouldCaptureAudioInUIProcess(should);
>+    WebKit::toImpl(configuration)->setShouldCaptureAudioInUIProcess(should);
> }
> 
> bool WKContextConfigurationProcessSwapsOnNavigation(WKContextConfigurationRef configuration)
> {
>-    return toImpl(configuration)->processSwapsOnNavigation();
>+    return WebKit::toImpl(configuration)->processSwapsOnNavigation();
> }
> 
> void WKContextConfigurationSetProcessSwapsOnNavigation(WKContextConfigurationRef configuration, bool swaps)
> {
>-    toImpl(configuration)->setProcessSwapsOnNavigation(swaps);
>+    WebKit::toImpl(configuration)->setProcessSwapsOnNavigation(swaps);
> }
> 
> bool WKContextConfigurationPrewarmsProcessesAutomatically(WKContextConfigurationRef configuration)
> {
>-    return toImpl(configuration)->isAutomaticProcessWarmingEnabled();
>+    return WebKit::toImpl(configuration)->isAutomaticProcessWarmingEnabled();
> }
> 
> void WKContextConfigurationSetPrewarmsProcessesAutomatically(WKContextConfigurationRef configuration, bool prewarms)
> {
>-    toImpl(configuration)->setIsAutomaticProcessWarmingEnabled(prewarms);
>+    WebKit::toImpl(configuration)->setIsAutomaticProcessWarmingEnabled(prewarms);
> }
> 
> bool WKContextConfigurationAlwaysKeepAndReuseSwappedProcesses(WKContextConfigurationRef configuration)
> {
>-    return toImpl(configuration)->alwaysKeepAndReuseSwappedProcesses();
>+    return WebKit::toImpl(configuration)->alwaysKeepAndReuseSwappedProcesses();
> }
> 
> void WKContextConfigurationSetAlwaysKeepAndReuseSwappedProcesses(WKContextConfigurationRef configuration, bool keepAndReuse)
> {
>-    toImpl(configuration)->setAlwaysKeepAndReuseSwappedProcesses(keepAndReuse);
>+    WebKit::toImpl(configuration)->setAlwaysKeepAndReuseSwappedProcesses(keepAndReuse);
> }
> 
> bool WKContextConfigurationProcessSwapsOnWindowOpenWithOpener(WKContextConfigurationRef configuration)
> {
>-    return toImpl(configuration)->processSwapsOnWindowOpenWithOpener();
>+    return WebKit::toImpl(configuration)->processSwapsOnWindowOpenWithOpener();
> }
> 
> void WKContextConfigurationSetProcessSwapsOnWindowOpenWithOpener(WKContextConfigurationRef configuration, bool swaps)
> {
>-    toImpl(configuration)->setProcessSwapsOnWindowOpenWithOpener(swaps);
>+    WebKit::toImpl(configuration)->setProcessSwapsOnWindowOpenWithOpener(swaps);
> }
> 
> int64_t WKContextConfigurationDiskCacheSizeOverride(WKContextConfigurationRef configuration)
>diff --git a/Source/WebKit/UIProcess/API/C/WKContextMenuListener.cpp b/Source/WebKit/UIProcess/API/C/WKContextMenuListener.cpp
>index 5963907b4a188f4f2c496d5f022372f7f3122fd2..c71b1648a606715ca86932409ffafc808c8c3230 100644
>--- a/Source/WebKit/UIProcess/API/C/WKContextMenuListener.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKContextMenuListener.cpp
>@@ -45,7 +45,7 @@ WKTypeID WKContextMenuListenerGetTypeID()
> void WKContextMenuListenerUseContextMenuItems(WKContextMenuListenerRef listenerRef, WKArrayRef arrayRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    RefPtr<API::Array> array = toImpl(arrayRef);
>+    RefPtr<API::Array> array = WebKit::toImpl(arrayRef);
>     size_t newSize = array ? array->size() : 0;
>     Vector<Ref<WebContextMenuItem>> items;
>     items.reserveInitialCapacity(newSize);
>@@ -57,7 +57,7 @@ void WKContextMenuListenerUseContextMenuItems(WKContextMenuListenerRef listenerR
>         items.uncheckedAppend(*item);
>     }
> 
>-    toImpl(listenerRef)->useContextMenuItems(WTFMove(items));
>+    WebKit::toImpl(listenerRef)->useContextMenuItems(WTFMove(items));
> #else
>     UNUSED_PARAM(listenerRef);
>     UNUSED_PARAM(arrayRef);
>diff --git a/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp b/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp
>index 490f3458ef80d4692c88f15a6a74cce743b64603..cf29c638b65535b1583ea8a4e82f7274d44e72c8 100644
>--- a/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp
>@@ -39,50 +39,50 @@ WKTypeID WKCookieManagerGetTypeID()
> 
> void WKCookieManagerSetClient(WKCookieManagerRef cookieManagerRef, const WKCookieManagerClientBase* wkClient)
> {
>-    toImpl(cookieManagerRef)->initializeClient(wkClient);
>+    WebKit::toImpl(cookieManagerRef)->initializeClient(wkClient);
> }
> 
> void WKCookieManagerGetHostnamesWithCookies(WKCookieManagerRef cookieManagerRef, void* context, WKCookieManagerGetCookieHostnamesFunction callback)
> {
>-    toImpl(cookieManagerRef)->getHostnamesWithCookies(PAL::SessionID::defaultSessionID(), toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(cookieManagerRef)->getHostnamesWithCookies(PAL::SessionID::defaultSessionID(), toGenericCallbackFunction(context, callback));
> }
> 
> void WKCookieManagerDeleteCookiesForHostname(WKCookieManagerRef cookieManagerRef, WKStringRef hostname)
> {
>-    toImpl(cookieManagerRef)->deleteCookiesForHostname(PAL::SessionID::defaultSessionID(), toImpl(hostname)->string());
>+    WebKit::toImpl(cookieManagerRef)->deleteCookiesForHostname(PAL::SessionID::defaultSessionID(), WebKit::toImpl(hostname)->string());
> }
> 
> void WKCookieManagerDeleteAllCookies(WKCookieManagerRef cookieManagerRef)
> {
>-    toImpl(cookieManagerRef)->deleteAllCookies(PAL::SessionID::defaultSessionID());
>+    WebKit::toImpl(cookieManagerRef)->deleteAllCookies(PAL::SessionID::defaultSessionID());
> }
> 
> void WKCookieManagerDeleteAllCookiesModifiedAfterDate(WKCookieManagerRef cookieManagerRef, double date)
> {
>-    toImpl(cookieManagerRef)->deleteAllCookiesModifiedSince(PAL::SessionID::defaultSessionID(), WallTime::fromRawSeconds(date), [](CallbackBase::Error){});
>+    WebKit::toImpl(cookieManagerRef)->deleteAllCookiesModifiedSince(PAL::SessionID::defaultSessionID(), WallTime::fromRawSeconds(date), [](CallbackBase::Error) { });
> }
> 
> void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy)
> {
>-    toImpl(cookieManager)->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [](CallbackBase::Error){});
>+    WebKit::toImpl(cookieManager)->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [](CallbackBase::Error) { });
> }
> 
> void WKCookieManagerGetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetHTTPCookieAcceptPolicyFunction callback)
> {
>-    toImpl(cookieManager)->getHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(context, callback));
>+    WebKit::toImpl(cookieManager)->getHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(context, callback));
> }
> 
> void WKCookieManagerSetStorageAccessAPIEnabled(WKCookieManagerRef cookieManager, bool enabled)
> {
>-    toImpl(cookieManager)->setStorageAccessAPIEnabled(enabled);
>+    WebKit::toImpl(cookieManager)->setStorageAccessAPIEnabled(enabled);
> }
> 
> void WKCookieManagerStartObservingCookieChanges(WKCookieManagerRef cookieManager)
> {
>-    toImpl(cookieManager)->startObservingCookieChanges(PAL::SessionID::defaultSessionID());
>+    WebKit::toImpl(cookieManager)->startObservingCookieChanges(PAL::SessionID::defaultSessionID());
> }
> 
> void WKCookieManagerStopObservingCookieChanges(WKCookieManagerRef cookieManager)
> {
>-    toImpl(cookieManager)->stopObservingCookieChanges(PAL::SessionID::defaultSessionID());
>+    WebKit::toImpl(cookieManager)->stopObservingCookieChanges(PAL::SessionID::defaultSessionID());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKCredential.cpp b/Source/WebKit/UIProcess/API/C/WKCredential.cpp
>index 35ecb203be20592205bccb2ae67af52a396de78f..c6e0f3c34c87eb5b43b52fb886372e0b73f3fd36 100644
>--- a/Source/WebKit/UIProcess/API/C/WKCredential.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKCredential.cpp
>@@ -40,16 +40,16 @@ WKTypeID WKCredentialGetTypeID()
> 
> WKCredentialRef WKCredentialCreate(WKStringRef username, WKStringRef password, WKCredentialPersistence persistence)
> {
>-    return toAPI(&WebCredential::create(WebCore::Credential(toImpl(username)->string(), toImpl(password)->string(), toCredentialPersistence(persistence))).leakRef());
>+    return toAPI(&WebCredential::create(WebCore::Credential(WebKit::toImpl(username)->string(), WebKit::toImpl(password)->string(), toCredentialPersistence(persistence))).leakRef());
> }
> 
> WKCredentialRef WKCredentialCreateWithCertificateInfo(WKCertificateInfoRef certificateInfo)
> {
>-    return toAPI(&WebCredential::create(toImpl(certificateInfo)).leakRef());
>+    return toAPI(&WebCredential::create(WebKit::toImpl(certificateInfo)).leakRef());
> }
> 
> WKStringRef WKCredentialCopyUser(WKCredentialRef credentialRef)
> {
>-    return toCopiedAPI(toImpl(credentialRef)->credential().user());
>+    return toCopiedAPI(WebKit::toImpl(credentialRef)->credential().user());
> }
> 
>diff --git a/Source/WebKit/UIProcess/API/C/WKDownload.cpp b/Source/WebKit/UIProcess/API/C/WKDownload.cpp
>index 48d8b8284c768d1d52b3fde5e27d179c9b325390..99949d126d8dfe3a433e4d091aa5526083ac0fdc 100644
>--- a/Source/WebKit/UIProcess/API/C/WKDownload.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKDownload.cpp
>@@ -42,32 +42,32 @@ WKTypeID WKDownloadGetTypeID()
> 
> uint64_t WKDownloadGetID(WKDownloadRef download)
> {
>-    return toImpl(download)->downloadID().downloadID();
>+    return WebKit::toImpl(download)->downloadID().downloadID();
> }
> 
> WKURLRequestRef WKDownloadCopyRequest(WKDownloadRef download)
> {
>-    return toAPI(&API::URLRequest::create(toImpl(download)->request()).leakRef());
>+    return toAPI(&API::URLRequest::create(WebKit::toImpl(download)->request()).leakRef());
> }
> 
> WKDataRef WKDownloadGetResumeData(WKDownloadRef download)
> {
>-    return toAPI(toImpl(download)->resumeData());
>+    return toAPI(WebKit::toImpl(download)->resumeData());
> }
> 
> void WKDownloadCancel(WKDownloadRef download)
> {
>-    return toImpl(download)->cancel();
>+    return WebKit::toImpl(download)->cancel();
> }
> 
> WKPageRef WKDownloadGetOriginatingPage(WKDownloadRef download)
> {
>-    return toAPI(toImpl(download)->originatingPage());
>+    return toAPI(WebKit::toImpl(download)->originatingPage());
> }
> 
> WKArrayRef WKDownloadCopyRedirectChain(WKDownloadRef download)
> {
>-    auto& redirectChain =  toImpl(download)->redirectChain();
>+    auto& redirectChain =  WebKit::toImpl(download)->redirectChain();
>     Vector<RefPtr<API::Object>> urls;
>     urls.reserveInitialCapacity(redirectChain.size());
>     for (auto& redirectURL : redirectChain)
>@@ -77,5 +77,5 @@ WKArrayRef WKDownloadCopyRedirectChain(WKDownloadRef download)
> 
> bool WKDownloadGetWasUserInitiated(WKDownloadRef download)
> {
>-    return toImpl(download)->wasUserInitiated();
>+    return WebKit::toImpl(download)->wasUserInitiated();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKFormSubmissionListener.cpp b/Source/WebKit/UIProcess/API/C/WKFormSubmissionListener.cpp
>index 842c53458bc1ebf7a0816ad870507295b8c0f65c..4dbd0a98a7cf30883a615796c479848718db8ba3 100644
>--- a/Source/WebKit/UIProcess/API/C/WKFormSubmissionListener.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKFormSubmissionListener.cpp
>@@ -38,5 +38,5 @@ WKTypeID WKFormSubmissionListenerGetTypeID()
> 
> void WKFormSubmissionListenerContinue(WKFormSubmissionListenerRef submissionListener)
> {
>-    toImpl(submissionListener)->continueSubmission();
>+    WebKit::toImpl(submissionListener)->continueSubmission();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKFrame.cpp b/Source/WebKit/UIProcess/API/C/WKFrame.cpp
>index a8562ea7f6567db3ac306f77b9103b9834aaba0c..3cfe39466c6eb536760d78cf1e1a485fa6abc696 100644
>--- a/Source/WebKit/UIProcess/API/C/WKFrame.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKFrame.cpp
>@@ -43,12 +43,12 @@ WKTypeID WKFrameGetTypeID()
> 
> bool WKFrameIsMainFrame(WKFrameRef frameRef)
> {
>-    return toImpl(frameRef)->isMainFrame();
>+    return WebKit::toImpl(frameRef)->isMainFrame();
> }
> 
> WKFrameLoadState WKFrameGetFrameLoadState(WKFrameRef frameRef)
> {
>-    WebFrameProxy* frame = toImpl(frameRef);
>+    WebFrameProxy* frame = WebKit::toImpl(frameRef);
>     switch (frame->frameLoadState().state()) {
>     case FrameLoadState::State::Provisional:
>         return kWKFrameLoadStateProvisional;
>@@ -64,90 +64,90 @@ WKFrameLoadState WKFrameGetFrameLoadState(WKFrameRef frameRef)
> 
> WKURLRef WKFrameCopyProvisionalURL(WKFrameRef frameRef)
> {
>-    return toCopiedURLAPI(toImpl(frameRef)->provisionalURL());
>+    return toCopiedURLAPI(WebKit::toImpl(frameRef)->provisionalURL());
> }
> 
> WKURLRef WKFrameCopyURL(WKFrameRef frameRef)
> {
>-    return toCopiedURLAPI(toImpl(frameRef)->url());
>+    return toCopiedURLAPI(WebKit::toImpl(frameRef)->url());
> }
> 
> WKURLRef WKFrameCopyUnreachableURL(WKFrameRef frameRef)
> {
>-    return toCopiedURLAPI(toImpl(frameRef)->unreachableURL());
>+    return toCopiedURLAPI(WebKit::toImpl(frameRef)->unreachableURL());
> }
> 
> void WKFrameStopLoading(WKFrameRef frameRef)
> {
>-    toImpl(frameRef)->stopLoading();
>+    WebKit::toImpl(frameRef)->stopLoading();
> }
> 
> WKStringRef WKFrameCopyMIMEType(WKFrameRef frameRef)
> {
>-    return toCopiedAPI(toImpl(frameRef)->mimeType());
>+    return toCopiedAPI(WebKit::toImpl(frameRef)->mimeType());
> }
> 
> WKStringRef WKFrameCopyTitle(WKFrameRef frameRef)
> {
>-    return toCopiedAPI(toImpl(frameRef)->title());
>+    return toCopiedAPI(WebKit::toImpl(frameRef)->title());
> }
> 
> WKPageRef WKFrameGetPage(WKFrameRef frameRef)
> {
>-    return toAPI(toImpl(frameRef)->page());
>+    return toAPI(WebKit::toImpl(frameRef)->page());
> }
> 
> WKCertificateInfoRef WKFrameGetCertificateInfo(WKFrameRef frameRef)
> {
>-    return toAPI(toImpl(frameRef)->certificateInfo());
>+    return toAPI(WebKit::toImpl(frameRef)->certificateInfo());
> }
> 
> bool WKFrameCanProvideSource(WKFrameRef frameRef)
> {
>-    return toImpl(frameRef)->canProvideSource();
>+    return WebKit::toImpl(frameRef)->canProvideSource();
> }
> 
> bool WKFrameCanShowMIMEType(WKFrameRef frameRef, WKStringRef mimeTypeRef)
> {
>-    return toImpl(frameRef)->canShowMIMEType(toWTFString(mimeTypeRef));
>+    return WebKit::toImpl(frameRef)->canShowMIMEType(toWTFString(mimeTypeRef));
> }
> 
> bool WKFrameIsDisplayingStandaloneImageDocument(WKFrameRef frameRef)
> {
>-    return toImpl(frameRef)->isDisplayingStandaloneImageDocument();
>+    return WebKit::toImpl(frameRef)->isDisplayingStandaloneImageDocument();
> }
> 
> bool WKFrameIsDisplayingMarkupDocument(WKFrameRef frameRef)
> {
>-    return toImpl(frameRef)->isDisplayingMarkupDocument();
>+    return WebKit::toImpl(frameRef)->isDisplayingMarkupDocument();
> }
> 
> bool WKFrameIsFrameSet(WKFrameRef frameRef)
> {
>-    return toImpl(frameRef)->isFrameSet();
>+    return WebKit::toImpl(frameRef)->isFrameSet();
> }
> 
> WKFrameHandleRef WKFrameCreateFrameHandle(WKFrameRef frameRef)
> {
>-    return toAPI(&API::FrameHandle::create(toImpl(frameRef)->frameID()).leakRef());
>+    return toAPI(&API::FrameHandle::create(WebKit::toImpl(frameRef)->frameID()).leakRef());
> }
> 
> WKFrameInfoRef WKFrameCreateFrameInfo(WKFrameRef frameRef)
> {
>-    return toAPI(&API::FrameInfo::create(*toImpl(frameRef), WebCore::SecurityOrigin::createFromString(toImpl(frameRef)->url())).leakRef());
>+    return toAPI(&API::FrameInfo::create(*WebKit::toImpl(frameRef), WebCore::SecurityOrigin::createFromString(WebKit::toImpl(frameRef)->url())).leakRef());
> }
> 
> void WKFrameGetMainResourceData(WKFrameRef frameRef, WKFrameGetResourceDataFunction callback, void* context)
> {
>-    toImpl(frameRef)->getMainResourceData(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(frameRef)->getMainResourceData(toGenericCallbackFunction(context, callback));
> }
> 
> void WKFrameGetResourceData(WKFrameRef frameRef, WKURLRef resourceURL, WKFrameGetResourceDataFunction callback, void* context)
> {
>-    toImpl(frameRef)->getResourceData(toImpl(resourceURL), toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(frameRef)->getResourceData(WebKit::toImpl(resourceURL), toGenericCallbackFunction(context, callback));
> }
> 
> void WKFrameGetWebArchive(WKFrameRef frameRef, WKFrameGetWebArchiveFunction callback, void* context)
> {
>-    toImpl(frameRef)->getWebArchive(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(frameRef)->getWebArchive(toGenericCallbackFunction(context, callback));
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKFrameHandleRef.cpp b/Source/WebKit/UIProcess/API/C/WKFrameHandleRef.cpp
>index b39fca1be57f0d274d8457f043f50eab62f23c58..eb4223c1b2a59ac6b8d6221b8c52addd9def31f4 100644
>--- a/Source/WebKit/UIProcess/API/C/WKFrameHandleRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKFrameHandleRef.cpp
>@@ -38,5 +38,5 @@ WKTypeID WKFrameHandleGetTypeID()
> 
> uint64_t WKFrameHandleGetFrameID(WKFrameHandleRef frameHandleRef)
> {
>-    return toImpl(frameHandleRef)->frameID();
>+    return WebKit::toImpl(frameHandleRef)->frameID();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKFrameInfoRef.cpp b/Source/WebKit/UIProcess/API/C/WKFrameInfoRef.cpp
>index 6ba5175bfe39a141b4f4be8fdb1a70b5fedfd51c..98b4ef2ffa258b1df19ab7d5c473198dc92ab93b 100644
>--- a/Source/WebKit/UIProcess/API/C/WKFrameInfoRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKFrameInfoRef.cpp
>@@ -39,5 +39,5 @@ WKTypeID WKFrameInfoGetTypeID()
> 
> WKFrameHandleRef WKFrameInfoGetFrameHandleRef(WKFrameInfoRef frameInfoRef)
> {
>-    return toAPI(&toImpl(frameInfoRef)->handle());
>+    return toAPI(&WebKit::toImpl(frameInfoRef)->handle());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKFramePolicyListener.cpp b/Source/WebKit/UIProcess/API/C/WKFramePolicyListener.cpp
>index a85b5bcd7ca5d6852b6b980e05abcdf5bd4d4c3a..472ed5cf8b3d4c940b20651dc832aecb0e59eddc 100644
>--- a/Source/WebKit/UIProcess/API/C/WKFramePolicyListener.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKFramePolicyListener.cpp
>@@ -43,22 +43,22 @@ WKTypeID WKFramePolicyListenerGetTypeID()
> 
> void WKFramePolicyListenerUse(WKFramePolicyListenerRef policyListenerRef)
> {
>-    toImpl(policyListenerRef)->use();
>+    WebKit::toImpl(policyListenerRef)->use();
> }
> 
> void WKFramePolicyListenerUseInNewProcess(WKFramePolicyListenerRef policyListenerRef)
> {
>-    toImpl(policyListenerRef)->use(nullptr, ProcessSwapRequestedByClient::Yes);
>+    WebKit::toImpl(policyListenerRef)->use(nullptr, ProcessSwapRequestedByClient::Yes);
> }
> 
> static void useWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies, ProcessSwapRequestedByClient processSwapRequestedByClient)
> {
>-    if (auto* websiteDataStore = toImpl(websitePolicies)->websiteDataStore()) {
>+    if (auto* websiteDataStore = WebKit::toImpl(websitePolicies)->websiteDataStore()) {
>         auto sessionID = websiteDataStore->websiteDataStore().sessionID();
>         RELEASE_ASSERT_WITH_MESSAGE(sessionID.isEphemeral() || sessionID == PAL::SessionID::defaultSessionID(), "If WebsitePolicies specifies a WebsiteDataStore, the data store's session must be default or non-persistent.");
>     }
> 
>-    toImpl(policyListenerRef)->use(toImpl(websitePolicies), processSwapRequestedByClient);
>+    WebKit::toImpl(policyListenerRef)->use(WebKit::toImpl(websitePolicies), processSwapRequestedByClient);
> }
> 
> void WKFramePolicyListenerUseWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies)
>@@ -73,10 +73,10 @@ void WKFramePolicyListenerUseInNewProcessWithPolicies(WKFramePolicyListenerRef p
> 
> void WKFramePolicyListenerDownload(WKFramePolicyListenerRef policyListenerRef)
> {
>-    toImpl(policyListenerRef)->download();
>+    WebKit::toImpl(policyListenerRef)->download();
> }
> 
> void WKFramePolicyListenerIgnore(WKFramePolicyListenerRef policyListenerRef)
> {
>-    toImpl(policyListenerRef)->ignore();
>+    WebKit::toImpl(policyListenerRef)->ignore();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKGeolocationManager.cpp b/Source/WebKit/UIProcess/API/C/WKGeolocationManager.cpp
>index 11b834b4ee2a9a687626c732bf58a48823f6334a..e86d04fe1734e4f5cd0041df4846e37bdfa8d617 100644
>--- a/Source/WebKit/UIProcess/API/C/WKGeolocationManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKGeolocationManager.cpp
>@@ -40,20 +40,20 @@ WKTypeID WKGeolocationManagerGetTypeID()
> 
> void WKGeolocationManagerSetProvider(WKGeolocationManagerRef geolocationManagerRef, const WKGeolocationProviderBase* wkProvider)
> {
>-    toImpl(geolocationManagerRef)->setProvider(std::make_unique<WebGeolocationProvider>(wkProvider));
>+    WebKit::toImpl(geolocationManagerRef)->setProvider(std::make_unique<WebGeolocationProvider>(wkProvider));
> }
> 
> void WKGeolocationManagerProviderDidChangePosition(WKGeolocationManagerRef geolocationManagerRef, WKGeolocationPositionRef positionRef)
> {
>-    toImpl(geolocationManagerRef)->providerDidChangePosition(toImpl(positionRef));
>+    WebKit::toImpl(geolocationManagerRef)->providerDidChangePosition(WebKit::toImpl(positionRef));
> }
> 
> void WKGeolocationManagerProviderDidFailToDeterminePosition(WKGeolocationManagerRef geolocationManagerRef)
> {
>-    toImpl(geolocationManagerRef)->providerDidFailToDeterminePosition();
>+    WebKit::toImpl(geolocationManagerRef)->providerDidFailToDeterminePosition();
> }
> 
> void WKGeolocationManagerProviderDidFailToDeterminePositionWithErrorMessage(WKGeolocationManagerRef geolocationManagerRef, WKStringRef errorMessage)
> {
>-    toImpl(geolocationManagerRef)->providerDidFailToDeterminePosition(toWTFString(errorMessage));
>+    WebKit::toImpl(geolocationManagerRef)->providerDidFailToDeterminePosition(toWTFString(errorMessage));
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKGeolocationPermissionRequest.cpp b/Source/WebKit/UIProcess/API/C/WKGeolocationPermissionRequest.cpp
>index 90aff12fd32a48b8bb2683a13e4eec07f1ade6d2..2cf7ddcef72f8bf8f3bf14e7a912963728072dde 100644
>--- a/Source/WebKit/UIProcess/API/C/WKGeolocationPermissionRequest.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKGeolocationPermissionRequest.cpp
>@@ -38,10 +38,10 @@ WKTypeID WKGeolocationPermissionRequestGetTypeID()
> 
> void WKGeolocationPermissionRequestAllow(WKGeolocationPermissionRequestRef geolocationPermissionRequestRef)
> {
>-    return toImpl(geolocationPermissionRequestRef)->allow();
>+    return WebKit::toImpl(geolocationPermissionRequestRef)->allow();
> }
> 
> void WKGeolocationPermissionRequestDeny(WKGeolocationPermissionRequestRef geolocationPermissionRequestRef)
> {
>-    return toImpl(geolocationPermissionRequestRef)->deny();
>+    return WebKit::toImpl(geolocationPermissionRequestRef)->deny();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKGrammarDetail.cpp b/Source/WebKit/UIProcess/API/C/WKGrammarDetail.cpp
>index e2f39cd1bf60011f856b9961748af45aaad72088..3480d556acc0ef551f409c12492ca0e5606993cb 100644
>--- a/Source/WebKit/UIProcess/API/C/WKGrammarDetail.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKGrammarDetail.cpp
>@@ -40,26 +40,26 @@ WKTypeID WKGrammarDetailGetTypeID()
> 
> WKGrammarDetailRef WKGrammarDetailCreate(int location, int length, WKArrayRef guesses, WKStringRef userDescription)
> {
>-    auto detail = WebGrammarDetail::create(location, length, toImpl(guesses), toWTFString(userDescription));
>+    auto detail = WebGrammarDetail::create(location, length, WebKit::toImpl(guesses), toWTFString(userDescription));
>     return toAPI(&detail.leakRef());
> }
> 
> int WKGrammarDetailGetLocation(WKGrammarDetailRef grammarDetailRef)
> {
>-    return toImpl(grammarDetailRef)->location();
>+    return WebKit::toImpl(grammarDetailRef)->location();
> }
> 
> int WKGrammarDetailGetLength(WKGrammarDetailRef grammarDetailRef)
> {
>-    return toImpl(grammarDetailRef)->length();
>+    return WebKit::toImpl(grammarDetailRef)->length();
> }
> 
> WKArrayRef WKGrammarDetailCopyGuesses(WKGrammarDetailRef grammarDetailRef)
> {
>-    return toAPI(&toImpl(grammarDetailRef)->guesses().leakRef());
>+    return toAPI(&WebKit::toImpl(grammarDetailRef)->guesses().leakRef());
> }
> 
> WKStringRef WKGrammarDetailCopyUserDescription(WKGrammarDetailRef grammarDetailRef)
> {
>-    return toCopiedAPI(toImpl(grammarDetailRef)->userDescription());
>+    return toCopiedAPI(WebKit::toImpl(grammarDetailRef)->userDescription());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKHitTestResult.cpp b/Source/WebKit/UIProcess/API/C/WKHitTestResult.cpp
>index 4082002b0725fd2b7206c9c4ee5489c1e2f3836a..b5dd4db08d0453d4e873626df9d1b2e1515b51a1 100644
>--- a/Source/WebKit/UIProcess/API/C/WKHitTestResult.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKHitTestResult.cpp
>@@ -39,45 +39,45 @@ WKTypeID WKHitTestResultGetTypeID()
> 
> WKURLRef WKHitTestResultCopyAbsoluteImageURL(WKHitTestResultRef hitTestResultRef)
> {
>-    return toCopiedURLAPI(toImpl(hitTestResultRef)->absoluteImageURL());
>+    return toCopiedURLAPI(WebKit::toImpl(hitTestResultRef)->absoluteImageURL());
> }
> 
> WKURLRef WKHitTestResultCopyAbsolutePDFURL(WKHitTestResultRef hitTestResultRef)
> {
>-    return toCopiedURLAPI(toImpl(hitTestResultRef)->absolutePDFURL());
>+    return toCopiedURLAPI(WebKit::toImpl(hitTestResultRef)->absolutePDFURL());
> }
> 
> WKURLRef WKHitTestResultCopyAbsoluteLinkURL(WKHitTestResultRef hitTestResultRef)
> {
>-    return toCopiedURLAPI(toImpl(hitTestResultRef)->absoluteLinkURL());
>+    return toCopiedURLAPI(WebKit::toImpl(hitTestResultRef)->absoluteLinkURL());
> }
> 
> WKURLRef WKHitTestResultCopyAbsoluteMediaURL(WKHitTestResultRef hitTestResultRef)
> {
>-    return toCopiedURLAPI(toImpl(hitTestResultRef)->absoluteMediaURL());
>+    return toCopiedURLAPI(WebKit::toImpl(hitTestResultRef)->absoluteMediaURL());
> }
> 
> WKStringRef WKHitTestResultCopyLinkLabel(WKHitTestResultRef hitTestResultRef)
> {
>-    return toCopiedAPI(toImpl(hitTestResultRef)->linkLabel());
>+    return toCopiedAPI(WebKit::toImpl(hitTestResultRef)->linkLabel());
> }
> 
> WKStringRef WKHitTestResultCopyLinkTitle(WKHitTestResultRef hitTestResultRef)
> {
>-    return toCopiedAPI(toImpl(hitTestResultRef)->linkTitle());
>+    return toCopiedAPI(WebKit::toImpl(hitTestResultRef)->linkTitle());
> }
> 
> WKStringRef WKHitTestResultCopyLookupText(WKHitTestResultRef hitTestResult)
> {
>-    return toCopiedAPI(toImpl(hitTestResult)->lookupText());
>+    return toCopiedAPI(WebKit::toImpl(hitTestResult)->lookupText());
> }
> 
> bool WKHitTestResultIsContentEditable(WKHitTestResultRef hitTestResultRef)
> {
>-    return toImpl(hitTestResultRef)->isContentEditable();
>+    return WebKit::toImpl(hitTestResultRef)->isContentEditable();
> }
> 
> WKRect WKHitTestResultGetElementBoundingBox(WKHitTestResultRef hitTestResultRef)
> {
>-    return toAPI(toImpl(hitTestResultRef)->elementBoundingBox());
>+    return toAPI(WebKit::toImpl(hitTestResultRef)->elementBoundingBox());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKInspector.cpp b/Source/WebKit/UIProcess/API/C/WKInspector.cpp
>index cd29eb6edd216f0b971a626ec30491bb49573fc3..ab247a4ff128d723675c6b6dd7b6cca51a9202c8 100644
>--- a/Source/WebKit/UIProcess/API/C/WKInspector.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKInspector.cpp
>@@ -41,94 +41,94 @@ WKTypeID WKInspectorGetTypeID()
> 
> WKPageRef WKInspectorGetPage(WKInspectorRef inspectorRef)
> {
>-    return toAPI(toImpl(inspectorRef)->inspectedPage());
>+    return toAPI(WebKit::toImpl(inspectorRef)->inspectedPage());
> }
> 
> bool WKInspectorIsConnected(WKInspectorRef inspectorRef)
> {
>-    return toImpl(inspectorRef)->isConnected();
>+    return WebKit::toImpl(inspectorRef)->isConnected();
> }
> 
> bool WKInspectorIsVisible(WKInspectorRef inspectorRef)
> {
>-    return toImpl(inspectorRef)->isVisible();
>+    return WebKit::toImpl(inspectorRef)->isVisible();
> }
> 
> bool WKInspectorIsFront(WKInspectorRef inspectorRef)
> {
>-    return toImpl(inspectorRef)->isFront();
>+    return WebKit::toImpl(inspectorRef)->isFront();
> }
> 
> void WKInspectorConnect(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->connect();
>+    WebKit::toImpl(inspectorRef)->connect();
> }
> 
> void WKInspectorShow(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->show();
>+    WebKit::toImpl(inspectorRef)->show();
> }
> 
> void WKInspectorHide(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->hide();
>+    WebKit::toImpl(inspectorRef)->hide();
> }
> 
> void WKInspectorClose(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->close();
>+    WebKit::toImpl(inspectorRef)->close();
> }
> 
> void WKInspectorShowConsole(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->showConsole();
>+    WebKit::toImpl(inspectorRef)->showConsole();
> }
> 
> void WKInspectorShowResources(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->showResources();
>+    WebKit::toImpl(inspectorRef)->showResources();
> }
> 
> void WKInspectorShowMainResourceForFrame(WKInspectorRef inspectorRef, WKFrameRef frameRef)
> {
>-    toImpl(inspectorRef)->showMainResourceForFrame(toImpl(frameRef));
>+    WebKit::toImpl(inspectorRef)->showMainResourceForFrame(WebKit::toImpl(frameRef));
> }
> 
> bool WKInspectorIsAttached(WKInspectorRef inspectorRef)
> {
>-    return toImpl(inspectorRef)->isAttached();
>+    return WebKit::toImpl(inspectorRef)->isAttached();
> }
> 
> void WKInspectorAttach(WKInspectorRef inspectorRef)
> {
>-    auto inspector = toImpl(inspectorRef);
>+    auto inspector = WebKit::toImpl(inspectorRef);
>     inspector->attach(inspector->attachmentSide());
> }
> 
> void WKInspectorDetach(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->detach();
>+    WebKit::toImpl(inspectorRef)->detach();
> }
> 
> bool WKInspectorIsProfilingPage(WKInspectorRef inspectorRef)
> {
>-    return toImpl(inspectorRef)->isProfilingPage();
>+    return WebKit::toImpl(inspectorRef)->isProfilingPage();
> }
> 
> void WKInspectorTogglePageProfiling(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->showTimelines();
>-    toImpl(inspectorRef)->togglePageProfiling();
>+    WebKit::toImpl(inspectorRef)->showTimelines();
>+    WebKit::toImpl(inspectorRef)->togglePageProfiling();
> }
> 
> bool WKInspectorIsElementSelectionActive(WKInspectorRef inspectorRef)
> {
>-    return toImpl(inspectorRef)->isElementSelectionActive();
>+    return WebKit::toImpl(inspectorRef)->isElementSelectionActive();
> }
> 
> void WKInspectorToggleElementSelection(WKInspectorRef inspectorRef)
> {
>-    toImpl(inspectorRef)->toggleElementSelection();
>+    WebKit::toImpl(inspectorRef)->toggleElementSelection();
> }
> 
> #endif // !PLATFORM(IOS_FAMILY)
>diff --git a/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp b/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>index efaebf7e66c3b22d3450ac1b9b211949ad0fd340..d233eb7da15c75ef4c6099ca36ba6b0c7fb07f35 100644
>--- a/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>@@ -62,7 +62,7 @@ WKStringRef WKKeyValueStorageManagerGetModificationTimeKey()
> void WKKeyValueStorageManagerGetKeyValueStorageOrigins(WKKeyValueStorageManagerRef keyValueStorageManager, void* context, WKKeyValueStorageManagerGetKeyValueStorageOriginsFunction callback)
> 
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>+    StorageManager* storageManager = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>     if (!storageManager) {
>         RunLoop::main().dispatch([context, callback] {
>             callback(toAPI(API::Array::create().ptr()), nullptr, context);
>@@ -82,7 +82,7 @@ void WKKeyValueStorageManagerGetKeyValueStorageOrigins(WKKeyValueStorageManagerR
> 
> void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerRef keyValueStorageManager, void* context, WKKeyValueStorageManagerGetStorageDetailsByOriginFunction callback)
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>+    StorageManager* storageManager = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>     if (!storageManager) {
>         RunLoop::main().dispatch([context, callback] {
>             callback(toAPI(API::Array::create().ptr()), nullptr, context);
>@@ -100,11 +100,11 @@ void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerR
> 
>             RefPtr<API::Object> origin = API::SecurityOrigin::create(WebCore::SecurityOriginData::fromDatabaseIdentifier(originDetails.originIdentifier)->securityOrigin());
> 
>-            detailsMap.set(toImpl(WKKeyValueStorageManagerGetOriginKey())->string(), origin);
>+            detailsMap.set(WebKit::toImpl(WKKeyValueStorageManagerGetOriginKey())->string(), origin);
>             if (originDetails.creationTime)
>-                detailsMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime->secondsSinceEpoch().value()));
>+                detailsMap.set(WebKit::toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime->secondsSinceEpoch().value()));
>             if (originDetails.modificationTime)
>-                detailsMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime->secondsSinceEpoch().value()));
>+                detailsMap.set(WebKit::toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime->secondsSinceEpoch().value()));
> 
>             result.uncheckedAppend(API::Dictionary::create(WTFMove(detailsMap)));
>         }
>@@ -115,16 +115,16 @@ void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerR
> 
> void WKKeyValueStorageManagerDeleteEntriesForOrigin(WKKeyValueStorageManagerRef keyValueStorageManager, WKSecurityOriginRef origin)
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>+    StorageManager* storageManager = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>     if (!storageManager)
>         return;
> 
>-    storageManager->deleteLocalStorageEntriesForOrigin(toImpl(origin)->securityOrigin().data());
>+    storageManager->deleteLocalStorageEntriesForOrigin(WebKit::toImpl(origin)->securityOrigin().data());
> }
> 
> void WKKeyValueStorageManagerDeleteAllEntries(WKKeyValueStorageManagerRef keyValueStorageManager)
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>+    StorageManager* storageManager = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>     if (!storageManager)
>         return;
> 
>diff --git a/Source/WebKit/UIProcess/API/C/WKMediaSessionFocusManager.cpp b/Source/WebKit/UIProcess/API/C/WKMediaSessionFocusManager.cpp
>index 9603bf0725a6dbc8f709492576c73f70b04e6b07..09c9bab190c7646d1ee4bddc201ce2fc132719bc 100644
>--- a/Source/WebKit/UIProcess/API/C/WKMediaSessionFocusManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKMediaSessionFocusManager.cpp
>@@ -43,7 +43,7 @@ WKTypeID WKMediaSessionFocusManagerGetTypeID()
> void WKMediaSessionFocusManagerSetClient(WKMediaSessionFocusManagerRef manager, const WKMediaSessionFocusManagerClientBase* client)
> {
> #if ENABLE(MEDIA_SESSION)
>-    toImpl(manager)->initializeClient(client);
>+    WebKit::toImpl(manager)->initializeClient(client);
> #else
>     UNUSED_PARAM(manager);
>     UNUSED_PARAM(client);
>@@ -53,7 +53,7 @@ void WKMediaSessionFocusManagerSetClient(WKMediaSessionFocusManagerRef manager,
> bool WKMediaSessionFocusManagerValueForPlaybackAttribute(WKMediaSessionFocusManagerRef manager, WKMediaSessionFocusManagerPlaybackAttribute attribute)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toImpl(manager)->valueForPlaybackAttribute(attribute);
>+    return WebKit::toImpl(manager)->valueForPlaybackAttribute(attribute);
> #else
>     UNUSED_PARAM(manager);
>     UNUSED_PARAM(attribute);
>@@ -64,7 +64,7 @@ bool WKMediaSessionFocusManagerValueForPlaybackAttribute(WKMediaSessionFocusMana
> void WKMediaSessionFocusManagerSetVolumeOfFocusedMediaElement(WKMediaSessionFocusManagerRef manager, double volume)
> {
> #if ENABLE(MEDIA_SESSION)
>-    toImpl(manager)->setVolumeOfFocusedMediaElement(volume);
>+    WebKit::toImpl(manager)->setVolumeOfFocusedMediaElement(volume);
> #else
>     UNUSED_PARAM(manager);
>     UNUSED_PARAM(volume);
>diff --git a/Source/WebKit/UIProcess/API/C/WKMediaSessionMetadata.cpp b/Source/WebKit/UIProcess/API/C/WKMediaSessionMetadata.cpp
>index 330ca53aa67c93cf135b746d5c90e59696483a51..2d034f3d61a585b6b31f536775e657afb78710ac 100644
>--- a/Source/WebKit/UIProcess/API/C/WKMediaSessionMetadata.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKMediaSessionMetadata.cpp
>@@ -43,7 +43,7 @@ WKTypeID WKMediaSessionMetadataGetTypeID()
> WKStringRef WKMediaSessionMetadataCopyTitle(WKMediaSessionMetadataRef metadata)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toCopiedAPI(toImpl(metadata)->title());
>+    return toCopiedAPI(WebKit::toImpl(metadata)->title());
> #else
>     UNUSED_PARAM(metadata);
>     return nullptr;
>@@ -53,7 +53,7 @@ WKStringRef WKMediaSessionMetadataCopyTitle(WKMediaSessionMetadataRef metadata)
> WKStringRef WKMediaSessionMetadataCopyArtist(WKMediaSessionMetadataRef metadata)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toCopiedAPI(toImpl(metadata)->artist());
>+    return toCopiedAPI(WebKit::toImpl(metadata)->artist());
> #else
>     UNUSED_PARAM(metadata);
>     return nullptr;
>@@ -63,7 +63,7 @@ WKStringRef WKMediaSessionMetadataCopyArtist(WKMediaSessionMetadataRef metadata)
> WKStringRef WKMediaSessionMetadataCopyAlbum(WKMediaSessionMetadataRef metadata)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toCopiedAPI(toImpl(metadata)->album());
>+    return toCopiedAPI(WebKit::toImpl(metadata)->album());
> #else
>     UNUSED_PARAM(metadata);
>     return nullptr;
>@@ -73,7 +73,7 @@ WKStringRef WKMediaSessionMetadataCopyAlbum(WKMediaSessionMetadataRef metadata)
> WKURLRef WKMediaSessionMetadataCopyArtworkURL(WKMediaSessionMetadataRef metadata)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toCopiedURLAPI(toImpl(metadata)->artworkURL());
>+    return toCopiedURLAPI(WebKit::toImpl(metadata)->artworkURL());
> #else
>     UNUSED_PARAM(metadata);
>     return nullptr;
>diff --git a/Source/WebKit/UIProcess/API/C/WKMockDisplay.cpp b/Source/WebKit/UIProcess/API/C/WKMockDisplay.cpp
>index ba6e0eb55d28cf16f92f7287fc267668b730061c..cdcc4763d417103f3cc40f0d4a07c900f92b6c1f 100644
>--- a/Source/WebKit/UIProcess/API/C/WKMockDisplay.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKMockDisplay.cpp
>@@ -35,5 +35,5 @@ using namespace WebKit;
> 
> void WKSendDisplayConfigurationChangedMessageForTesting(WKContextRef context)
> {
>-    toImpl(context)->sendDisplayConfigurationChangedMessageForTesting();
>+    WebKit::toImpl(context)->sendDisplayConfigurationChangedMessageForTesting();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKMockMediaDevice.cpp b/Source/WebKit/UIProcess/API/C/WKMockMediaDevice.cpp
>index f276365133caa429487965a9c38e315028fbf845..b7696957ebab7133daec1bb65179c0dc242ec32e 100644
>--- a/Source/WebKit/UIProcess/API/C/WKMockMediaDevice.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKMockMediaDevice.cpp
>@@ -46,21 +46,21 @@ void WKAddMockMediaDevice(WKContextRef context, WKStringRef persistentId, WKStri
>     else if (typeString != "microphone")
>         return;
> 
>-    toImpl(context)->addMockMediaDevice({ WebKit::toImpl(persistentId)->string(), WebKit::toImpl(label)->string(), WTFMove(properties) });
>+    WebKit::toImpl(context)->addMockMediaDevice({ WebKit::toImpl(persistentId)->string(), WebKit::toImpl(label)->string(), WTFMove(properties) });
> #endif
> }
> 
> void WKClearMockMediaDevices(WKContextRef context)
> {
>-    toImpl(context)->clearMockMediaDevices();
>+    WebKit::toImpl(context)->clearMockMediaDevices();
> }
> 
> void WKRemoveMockMediaDevice(WKContextRef context, WKStringRef persistentId)
> {
>-    toImpl(context)->removeMockMediaDevice(WebKit::toImpl(persistentId)->string());
>+    WebKit::toImpl(context)->removeMockMediaDevice(WebKit::toImpl(persistentId)->string());
> }
> 
> void WKResetMockMediaDevices(WKContextRef context)
> {
>-    toImpl(context)->resetMockMediaDevices();
>+    WebKit::toImpl(context)->resetMockMediaDevices();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKNavigationDataRef.cpp b/Source/WebKit/UIProcess/API/C/WKNavigationDataRef.cpp
>index 0a815bb827e6f124ffa49fdff61051e3906f66b4..54da70489dbe788ed1706d4d7777acdddff81a6f 100644
>--- a/Source/WebKit/UIProcess/API/C/WKNavigationDataRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKNavigationDataRef.cpp
>@@ -39,21 +39,21 @@ WKTypeID WKNavigationDataGetTypeID()
> 
> WKStringRef WKNavigationDataCopyTitle(WKNavigationDataRef navigationDataRef)
> {
>-    return toCopiedAPI(toImpl(navigationDataRef)->title());
>+    return toCopiedAPI(WebKit::toImpl(navigationDataRef)->title());
> }
> 
> WKURLRef WKNavigationDataCopyURL(WKNavigationDataRef navigationDataRef)
> {
>     // This returns the URL of the original request for backwards-compatibility purposes.
>-    return toCopiedURLAPI(toImpl(navigationDataRef)->originalRequest().url());
>+    return toCopiedURLAPI(WebKit::toImpl(navigationDataRef)->originalRequest().url());
> }
> 
> WKURLRef WKNavigationDataCopyNavigationDestinationURL(WKNavigationDataRef navigationDataRef)
> {
>-    return toCopiedURLAPI(toImpl(navigationDataRef)->url());
>+    return toCopiedURLAPI(WebKit::toImpl(navigationDataRef)->url());
> }
> 
> WKURLRequestRef WKNavigationDataCopyOriginalRequest(WKNavigationDataRef navigationData)
> {
>-    return toAPI(&API::URLRequest::create(toImpl(navigationData)->originalRequest()).leakRef());
>+    return toAPI(&API::URLRequest::create(WebKit::toImpl(navigationData)->originalRequest()).leakRef());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKNavigationResponseRef.cpp b/Source/WebKit/UIProcess/API/C/WKNavigationResponseRef.cpp
>index ed6f21b0f73c88963f8fa8ab13289372ce66ea2f..0f191d963e52d66cda6a16da36fdcb99239e24b8 100644
>--- a/Source/WebKit/UIProcess/API/C/WKNavigationResponseRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKNavigationResponseRef.cpp
>@@ -38,5 +38,5 @@ WKTypeID WKNavigationResponseGetTypeID()
> 
> bool WKNavigationResponseCanShowMIMEType(WKNavigationResponseRef response)
> {
>-    return toImpl(response)->canShowMIMEType();
>+    return WebKit::toImpl(response)->canShowMIMEType();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKNotification.cpp b/Source/WebKit/UIProcess/API/C/WKNotification.cpp
>index 8b6c0344406e99c77a78e9fc76837976bf7b0aa6..4f90319fb16b2750819b65d829b92136c35fc305 100644
>--- a/Source/WebKit/UIProcess/API/C/WKNotification.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKNotification.cpp
>@@ -41,32 +41,32 @@ WKTypeID WKNotificationGetTypeID()
> 
> WKStringRef WKNotificationCopyTitle(WKNotificationRef notification)
> {
>-    return toCopiedAPI(toImpl(notification)->title());
>+    return toCopiedAPI(WebKit::toImpl(notification)->title());
> }
> 
> WKStringRef WKNotificationCopyBody(WKNotificationRef notification)
> {
>-    return toCopiedAPI(toImpl(notification)->body());
>+    return toCopiedAPI(WebKit::toImpl(notification)->body());
> }
> 
> WKStringRef WKNotificationCopyIconURL(WKNotificationRef notification)
> {
>-    return toCopiedAPI(toImpl(notification)->iconURL());
>+    return toCopiedAPI(WebKit::toImpl(notification)->iconURL());
> }
> 
> WKStringRef WKNotificationCopyTag(WKNotificationRef notification)
> {
>-    return toCopiedAPI(toImpl(notification)->tag());
>+    return toCopiedAPI(WebKit::toImpl(notification)->tag());
> }
> 
> WKStringRef WKNotificationCopyLang(WKNotificationRef notification)
> {
>-    return toCopiedAPI(toImpl(notification)->lang());
>+    return toCopiedAPI(WebKit::toImpl(notification)->lang());
> }
> 
> WKStringRef WKNotificationCopyDir(WKNotificationRef notification)
> {
>-    switch (toImpl(notification)->dir()) {
>+    switch (WebKit::toImpl(notification)->dir()) {
>     case WebCore::NotificationDirection::Auto:
>         return WKStringCreateWithUTF8CString("auto");
>     case WebCore::NotificationDirection::Ltr:
>@@ -80,10 +80,10 @@ WKStringRef WKNotificationCopyDir(WKNotificationRef notification)
> 
> WKSecurityOriginRef WKNotificationGetSecurityOrigin(WKNotificationRef notification)
> {
>-    return toAPI(toImpl(notification)->origin());
>+    return toAPI(WebKit::toImpl(notification)->origin());
> }
> 
> uint64_t WKNotificationGetID(WKNotificationRef notification)
> {
>-    return toImpl(notification)->notificationID();
>+    return WebKit::toImpl(notification)->notificationID();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKNotificationManager.cpp b/Source/WebKit/UIProcess/API/C/WKNotificationManager.cpp
>index b223d6f87bfa5e96e3e50da2dd78ff0d2dd416ce..6ae9cb116aa73d49e6d8b0b85399e8c4c5090756 100644
>--- a/Source/WebKit/UIProcess/API/C/WKNotificationManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKNotificationManager.cpp
>@@ -41,35 +41,35 @@ WKTypeID WKNotificationManagerGetTypeID()
> 
> void WKNotificationManagerSetProvider(WKNotificationManagerRef managerRef, const WKNotificationProviderBase* wkProvider)
> {
>-    toImpl(managerRef)->setProvider(std::make_unique<WebNotificationProvider>(wkProvider));
>+    WebKit::toImpl(managerRef)->setProvider(std::make_unique<WebNotificationProvider>(wkProvider));
> }
> 
> void WKNotificationManagerProviderDidShowNotification(WKNotificationManagerRef managerRef, uint64_t notificationID)
> {
>-    toImpl(managerRef)->providerDidShowNotification(notificationID);
>+    WebKit::toImpl(managerRef)->providerDidShowNotification(notificationID);
> }
> 
> void WKNotificationManagerProviderDidClickNotification(WKNotificationManagerRef managerRef, uint64_t notificationID)
> {
>-    toImpl(managerRef)->providerDidClickNotification(notificationID);
>+    WebKit::toImpl(managerRef)->providerDidClickNotification(notificationID);
> }
> 
> void WKNotificationManagerProviderDidCloseNotifications(WKNotificationManagerRef managerRef, WKArrayRef notificationIDs)
> {
>-    toImpl(managerRef)->providerDidCloseNotifications(toImpl(notificationIDs));
>+    WebKit::toImpl(managerRef)->providerDidCloseNotifications(WebKit::toImpl(notificationIDs));
> }
> 
> void WKNotificationManagerProviderDidUpdateNotificationPolicy(WKNotificationManagerRef managerRef, WKSecurityOriginRef origin, bool allowed)
> {
>-    toImpl(managerRef)->providerDidUpdateNotificationPolicy(toImpl(origin), allowed);
>+    WebKit::toImpl(managerRef)->providerDidUpdateNotificationPolicy(WebKit::toImpl(origin), allowed);
> }
> 
> void WKNotificationManagerProviderDidRemoveNotificationPolicies(WKNotificationManagerRef managerRef, WKArrayRef origins)
> {
>-    toImpl(managerRef)->providerDidRemoveNotificationPolicies(toImpl(origins));
>+    WebKit::toImpl(managerRef)->providerDidRemoveNotificationPolicies(WebKit::toImpl(origins));
> }
> 
> uint64_t WKNotificationManagerGetLocalIDForTesting(WKNotificationManagerRef manager, WKNotificationRef notification)
> {
>-    return toImpl(manager)->notificationLocalIDForTesting(toImpl(notification));
>+    return WebKit::toImpl(manager)->notificationLocalIDForTesting(WebKit::toImpl(notification));
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKNotificationPermissionRequest.cpp b/Source/WebKit/UIProcess/API/C/WKNotificationPermissionRequest.cpp
>index 596348d726edc42b0c77040b995cc887fe1e54ac..7e74fa1f367e2969e9ed86c6d5ac55ebcebc66f1 100644
>--- a/Source/WebKit/UIProcess/API/C/WKNotificationPermissionRequest.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKNotificationPermissionRequest.cpp
>@@ -38,10 +38,10 @@ WKTypeID WKNotificationPermissionRequestGetTypeID()
> 
> void WKNotificationPermissionRequestAllow(WKNotificationPermissionRequestRef notificationPermissionRequest)
> {
>-    return toImpl(notificationPermissionRequest)->allow();
>+    return WebKit::toImpl(notificationPermissionRequest)->allow();
> }
> 
> void WKNotificationPermissionRequestDeny(WKNotificationPermissionRequestRef notificationPermissionRequest)
> {
>-    return toImpl(notificationPermissionRequest)->deny();
>+    return WebKit::toImpl(notificationPermissionRequest)->deny();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKOpenPanelParametersRef.cpp b/Source/WebKit/UIProcess/API/C/WKOpenPanelParametersRef.cpp
>index afaf6e48bc36a95772c13e57c2b2a82d18dd3474..12fcd4b978cb73667edaa14142dcdfe72d5b9e87 100644
>--- a/Source/WebKit/UIProcess/API/C/WKOpenPanelParametersRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKOpenPanelParametersRef.cpp
>@@ -40,22 +40,22 @@ WKTypeID WKOpenPanelParametersGetTypeID()
> 
> bool WKOpenPanelParametersGetAllowsDirectories(WKOpenPanelParametersRef parametersRef)
> {
>-    return toImpl(parametersRef)->allowDirectories();
>+    return WebKit::toImpl(parametersRef)->allowDirectories();
> }
> 
> bool WKOpenPanelParametersGetAllowsMultipleFiles(WKOpenPanelParametersRef parametersRef)
> {
>-    return toImpl(parametersRef)->allowMultipleFiles();
>+    return WebKit::toImpl(parametersRef)->allowMultipleFiles();
> }
> 
> WKArrayRef WKOpenPanelParametersCopyAcceptedMIMETypes(WKOpenPanelParametersRef parametersRef)
> {
>-    return toAPI(&toImpl(parametersRef)->acceptMIMETypes().leakRef());
>+    return toAPI(&WebKit::toImpl(parametersRef)->acceptMIMETypes().leakRef());
> }
> 
> WKArrayRef WKOpenPanelParametersCopyAcceptedFileExtensions(WKOpenPanelParametersRef parametersRef)
> {
>-    return toAPI(&toImpl(parametersRef)->acceptFileExtensions().leakRef());
>+    return toAPI(&WebKit::toImpl(parametersRef)->acceptFileExtensions().leakRef());
> }
> 
> // Deprecated.
>@@ -67,7 +67,7 @@ WKStringRef WKOpenPanelParametersCopyCapture(WKOpenPanelParametersRef)
> bool WKOpenPanelParametersGetMediaCaptureType(WKOpenPanelParametersRef parametersRef)
> {
> #if ENABLE(MEDIA_CAPTURE)
>-    return toImpl(parametersRef)->mediaCaptureType();
>+    return WebKit::toImpl(parametersRef)->mediaCaptureType();
> #else
>     UNUSED_PARAM(parametersRef);
>     return false;
>@@ -76,5 +76,5 @@ bool WKOpenPanelParametersGetMediaCaptureType(WKOpenPanelParametersRef parameter
> 
> WKArrayRef WKOpenPanelParametersCopySelectedFileNames(WKOpenPanelParametersRef parametersRef)
> {
>-    return toAPI(&toImpl(parametersRef)->selectedFileNames().leakRef());
>+    return toAPI(&WebKit::toImpl(parametersRef)->selectedFileNames().leakRef());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKOpenPanelResultListener.cpp b/Source/WebKit/UIProcess/API/C/WKOpenPanelResultListener.cpp
>index 4a0ffc42e5941c306bcffbf88ce15acc7099b5ce..8a6e2ddc4cad7739fb4fb857ee5867b00d75d75a 100644
>--- a/Source/WebKit/UIProcess/API/C/WKOpenPanelResultListener.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKOpenPanelResultListener.cpp
>@@ -56,10 +56,10 @@ static Vector<String> filePathsFromFileURLs(const API::Array& fileURLs)
> 
> void WKOpenPanelResultListenerChooseFiles(WKOpenPanelResultListenerRef listenerRef, WKArrayRef fileURLsRef)
> {
>-    toImpl(listenerRef)->chooseFiles(filePathsFromFileURLs(*toImpl(fileURLsRef)));
>+    WebKit::toImpl(listenerRef)->chooseFiles(filePathsFromFileURLs(*WebKit::toImpl(fileURLsRef)));
> }
> 
> void WKOpenPanelResultListenerCancel(WKOpenPanelResultListenerRef listenerRef)
> {
>-    toImpl(listenerRef)->cancel();
>+    WebKit::toImpl(listenerRef)->cancel();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKPage.cpp b/Source/WebKit/UIProcess/API/C/WKPage.cpp
>index 2537439641b6ffe27e1626155438525150334668..a6d5d756bc6f4c886cda98ee8dc15408a8076034 100644
>--- a/Source/WebKit/UIProcess/API/C/WKPage.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKPage.cpp
>@@ -140,65 +140,65 @@ WKTypeID WKPageGetTypeID()
> 
> WKContextRef WKPageGetContext(WKPageRef pageRef)
> {
>-    return toAPI(&toImpl(pageRef)->process().processPool());
>+    return toAPI(&WebKit::toImpl(pageRef)->process().processPool());
> }
> 
> WKPageGroupRef WKPageGetPageGroup(WKPageRef pageRef)
> {
>-    return toAPI(&toImpl(pageRef)->pageGroup());
>+    return toAPI(&WebKit::toImpl(pageRef)->pageGroup());
> }
> 
> WKPageConfigurationRef WKPageCopyPageConfiguration(WKPageRef pageRef)
> {
>-    return toAPI(&toImpl(pageRef)->configuration().copy().leakRef());
>+    return toAPI(&WebKit::toImpl(pageRef)->configuration().copy().leakRef());
> }
> 
> void WKPageLoadURL(WKPageRef pageRef, WKURLRef URLRef)
> {
>-    toImpl(pageRef)->loadRequest(URL(URL(), toWTFString(URLRef)));
>+    WebKit::toImpl(pageRef)->loadRequest(URL(URL(), toWTFString(URLRef)));
> }
> 
> void WKPageLoadURLWithShouldOpenExternalURLsPolicy(WKPageRef pageRef, WKURLRef URLRef, bool shouldOpenExternalURLs)
> {
>     ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy = shouldOpenExternalURLs ? ShouldOpenExternalURLsPolicy::ShouldAllow : ShouldOpenExternalURLsPolicy::ShouldNotAllow;
>-    toImpl(pageRef)->loadRequest(URL(URL(), toWTFString(URLRef)), shouldOpenExternalURLsPolicy);
>+    WebKit::toImpl(pageRef)->loadRequest(URL(URL(), toWTFString(URLRef)), shouldOpenExternalURLsPolicy);
> }
> 
> void WKPageLoadURLWithUserData(WKPageRef pageRef, WKURLRef URLRef, WKTypeRef userDataRef)
> {
>-    toImpl(pageRef)->loadRequest(URL(URL(), toWTFString(URLRef)), ShouldOpenExternalURLsPolicy::ShouldNotAllow, toImpl(userDataRef));
>+    WebKit::toImpl(pageRef)->loadRequest(URL(URL(), toWTFString(URLRef)), ShouldOpenExternalURLsPolicy::ShouldNotAllow, WebKit::toImpl(userDataRef));
> }
> 
> void WKPageLoadURLRequest(WKPageRef pageRef, WKURLRequestRef urlRequestRef)
> {
>-    auto resourceRequest = toImpl(urlRequestRef)->resourceRequest();
>-    toImpl(pageRef)->loadRequest(WTFMove(resourceRequest));
>+    auto resourceRequest = WebKit::toImpl(urlRequestRef)->resourceRequest();
>+    WebKit::toImpl(pageRef)->loadRequest(WTFMove(resourceRequest));
> }
> 
> void WKPageLoadURLRequestWithUserData(WKPageRef pageRef, WKURLRequestRef urlRequestRef, WKTypeRef userDataRef)
> {
>-    auto resourceRequest = toImpl(urlRequestRef)->resourceRequest();
>-    toImpl(pageRef)->loadRequest(WTFMove(resourceRequest), ShouldOpenExternalURLsPolicy::ShouldNotAllow, toImpl(userDataRef));
>+    auto resourceRequest = WebKit::toImpl(urlRequestRef)->resourceRequest();
>+    WebKit::toImpl(pageRef)->loadRequest(WTFMove(resourceRequest), ShouldOpenExternalURLsPolicy::ShouldNotAllow, WebKit::toImpl(userDataRef));
> }
> 
> void WKPageLoadFile(WKPageRef pageRef, WKURLRef fileURL, WKURLRef resourceDirectoryURL)
> {
>-    toImpl(pageRef)->loadFile(toWTFString(fileURL), toWTFString(resourceDirectoryURL));
>+    WebKit::toImpl(pageRef)->loadFile(toWTFString(fileURL), toWTFString(resourceDirectoryURL));
> }
> 
> void WKPageLoadFileWithUserData(WKPageRef pageRef, WKURLRef fileURL, WKURLRef resourceDirectoryURL, WKTypeRef userDataRef)
> {
>-    toImpl(pageRef)->loadFile(toWTFString(fileURL), toWTFString(resourceDirectoryURL), toImpl(userDataRef));
>+    WebKit::toImpl(pageRef)->loadFile(toWTFString(fileURL), toWTFString(resourceDirectoryURL), WebKit::toImpl(userDataRef));
> }
> 
> void WKPageLoadData(WKPageRef pageRef, WKDataRef dataRef, WKStringRef MIMETypeRef, WKStringRef encodingRef, WKURLRef baseURLRef)
> {
>-    toImpl(pageRef)->loadData(toImpl(dataRef)->dataReference(), toWTFString(MIMETypeRef), toWTFString(encodingRef), toWTFString(baseURLRef));
>+    WebKit::toImpl(pageRef)->loadData(WebKit::toImpl(dataRef)->dataReference(), toWTFString(MIMETypeRef), toWTFString(encodingRef), toWTFString(baseURLRef));
> }
> 
> void WKPageLoadDataWithUserData(WKPageRef pageRef, WKDataRef dataRef, WKStringRef MIMETypeRef, WKStringRef encodingRef, WKURLRef baseURLRef, WKTypeRef userDataRef)
> {
>-    toImpl(pageRef)->loadData(toImpl(dataRef)->dataReference(), toWTFString(MIMETypeRef), toWTFString(encodingRef), toWTFString(baseURLRef), toImpl(userDataRef));
>+    WebKit::toImpl(pageRef)->loadData(WebKit::toImpl(dataRef)->dataReference(), toWTFString(MIMETypeRef), toWTFString(encodingRef), toWTFString(baseURLRef), WebKit::toImpl(userDataRef));
> }
> 
> static String encodingOf(const String& string)
>@@ -218,7 +218,7 @@ static IPC::DataReference dataFrom(const String& string)
> static void loadString(WKPageRef pageRef, WKStringRef stringRef, const String& mimeType, const String& baseURL, WKTypeRef userDataRef)
> {
>     String string = toWTFString(stringRef);
>-    toImpl(pageRef)->loadData(dataFrom(string), mimeType, encodingOf(string), baseURL, toImpl(userDataRef));
>+    WebKit::toImpl(pageRef)->loadData(dataFrom(string), mimeType, encodingOf(string), baseURL, WebKit::toImpl(userDataRef));
> }
> 
> void WKPageLoadHTMLString(WKPageRef pageRef, WKStringRef htmlStringRef, WKURLRef baseURLRef)
>@@ -239,7 +239,7 @@ void WKPageLoadAlternateHTMLString(WKPageRef pageRef, WKStringRef htmlStringRef,
> void WKPageLoadAlternateHTMLStringWithUserData(WKPageRef pageRef, WKStringRef htmlStringRef, WKURLRef baseURLRef, WKURLRef unreachableURLRef, WKTypeRef userDataRef)
> {
>     String string = toWTFString(htmlStringRef);
>-    toImpl(pageRef)->loadAlternateHTML(dataFrom(string), encodingOf(string), URL(URL(), toWTFString(baseURLRef)), URL(URL(), toWTFString(unreachableURLRef)), toImpl(userDataRef));
>+    WebKit::toImpl(pageRef)->loadAlternateHTML(dataFrom(string), encodingOf(string), URL(URL(), toWTFString(baseURLRef)), URL(URL(), toWTFString(unreachableURLRef)), WebKit::toImpl(userDataRef));
> }
> 
> void WKPageLoadPlainTextString(WKPageRef pageRef, WKStringRef plainTextStringRef)
>@@ -254,17 +254,17 @@ void WKPageLoadPlainTextStringWithUserData(WKPageRef pageRef, WKStringRef plainT
> 
> void WKPageLoadWebArchiveData(WKPageRef pageRef, WKDataRef webArchiveDataRef)
> {
>-    toImpl(pageRef)->loadWebArchiveData(toImpl(webArchiveDataRef));
>+    WebKit::toImpl(pageRef)->loadWebArchiveData(WebKit::toImpl(webArchiveDataRef));
> }
> 
> void WKPageLoadWebArchiveDataWithUserData(WKPageRef pageRef, WKDataRef webArchiveDataRef, WKTypeRef userDataRef)
> {
>-    toImpl(pageRef)->loadWebArchiveData(toImpl(webArchiveDataRef), toImpl(userDataRef));
>+    WebKit::toImpl(pageRef)->loadWebArchiveData(WebKit::toImpl(webArchiveDataRef), WebKit::toImpl(userDataRef));
> }
> 
> void WKPageStopLoading(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->stopLoading();
>+    WebKit::toImpl(pageRef)->stopLoading();
> }
> 
> void WKPageReload(WKPageRef pageRef)
>@@ -275,144 +275,144 @@ void WKPageReload(WKPageRef pageRef)
>         reloadOptions.add(WebCore::ReloadOption::ExpiredOnly);
> #endif
> 
>-    toImpl(pageRef)->reload(reloadOptions);
>+    WebKit::toImpl(pageRef)->reload(reloadOptions);
> }
> 
> void WKPageReloadWithoutContentBlockers(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->reload(WebCore::ReloadOption::DisableContentBlockers);
>+    WebKit::toImpl(pageRef)->reload(WebCore::ReloadOption::DisableContentBlockers);
> }
> 
> void WKPageReloadFromOrigin(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->reload(WebCore::ReloadOption::FromOrigin);
>+    WebKit::toImpl(pageRef)->reload(WebCore::ReloadOption::FromOrigin);
> }
> 
> void WKPageReloadExpiredOnly(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->reload(WebCore::ReloadOption::ExpiredOnly);
>+    WebKit::toImpl(pageRef)->reload(WebCore::ReloadOption::ExpiredOnly);
> }
> 
> bool WKPageTryClose(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->tryClose();
>+    return WebKit::toImpl(pageRef)->tryClose();
> }
> 
> void WKPageClose(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->close();
>+    WebKit::toImpl(pageRef)->close();
> }
> 
> bool WKPageIsClosed(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->isClosed();
>+    return WebKit::toImpl(pageRef)->isClosed();
> }
> 
> void WKPageGoForward(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->goForward();
>+    WebKit::toImpl(pageRef)->goForward();
> }
> 
> bool WKPageCanGoForward(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->backForwardList().forwardItem();
>+    return WebKit::toImpl(pageRef)->backForwardList().forwardItem();
> }
> 
> void WKPageGoBack(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->goBack();
>+    WebKit::toImpl(pageRef)->goBack();
> }
> 
> bool WKPageCanGoBack(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->backForwardList().backItem();
>+    return WebKit::toImpl(pageRef)->backForwardList().backItem();
> }
> 
> void WKPageGoToBackForwardListItem(WKPageRef pageRef, WKBackForwardListItemRef itemRef)
> {
>-    toImpl(pageRef)->goToBackForwardItem(*toImpl(itemRef));
>+    WebKit::toImpl(pageRef)->goToBackForwardItem(*WebKit::toImpl(itemRef));
> }
> 
> void WKPageTryRestoreScrollPosition(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->tryRestoreScrollPosition();
>+    WebKit::toImpl(pageRef)->tryRestoreScrollPosition();
> }
> 
> WKBackForwardListRef WKPageGetBackForwardList(WKPageRef pageRef)
> {
>-    return toAPI(&toImpl(pageRef)->backForwardList());
>+    return toAPI(&WebKit::toImpl(pageRef)->backForwardList());
> }
> 
> bool WKPageWillHandleHorizontalScrollEvents(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->willHandleHorizontalScrollEvents();
>+    return WebKit::toImpl(pageRef)->willHandleHorizontalScrollEvents();
> }
> 
> void WKPageUpdateWebsitePolicies(WKPageRef pageRef, WKWebsitePoliciesRef websitePoliciesRef)
> {
>-    auto data = toImpl(websitePoliciesRef)->data();
>+    auto data = WebKit::toImpl(websitePoliciesRef)->data();
>     RELEASE_ASSERT_WITH_MESSAGE(!data.websiteDataStoreParameters, "Setting WebsitePolicies.WebsiteDataStore is only supported during WKFramePolicyListenerUseWithPolicies().");
>-    toImpl(pageRef)->updateWebsitePolicies(WTFMove(data));
>+    WebKit::toImpl(pageRef)->updateWebsitePolicies(WTFMove(data));
> }
> 
> WKStringRef WKPageCopyTitle(WKPageRef pageRef)
> {
>-    return toCopiedAPI(toImpl(pageRef)->pageLoadState().title());
>+    return toCopiedAPI(WebKit::toImpl(pageRef)->pageLoadState().title());
> }
> 
> WKFrameRef WKPageGetMainFrame(WKPageRef pageRef)
> {
>-    return toAPI(toImpl(pageRef)->mainFrame());
>+    return toAPI(WebKit::toImpl(pageRef)->mainFrame());
> }
> 
> WKFrameRef WKPageGetFocusedFrame(WKPageRef pageRef)
> {
>-    return toAPI(toImpl(pageRef)->focusedFrame());
>+    return toAPI(WebKit::toImpl(pageRef)->focusedFrame());
> }
> 
> WKFrameRef WKPageGetFrameSetLargestFrame(WKPageRef pageRef)
> {
>-    return toAPI(toImpl(pageRef)->frameSetLargestFrame());
>+    return toAPI(WebKit::toImpl(pageRef)->frameSetLargestFrame());
> }
> 
> uint64_t WKPageGetRenderTreeSize(WKPageRef page)
> {
>-    return toImpl(page)->renderTreeSize();
>+    return WebKit::toImpl(page)->renderTreeSize();
> }
> 
> WKInspectorRef WKPageGetInspector(WKPageRef pageRef)
> {
>-    return toAPI(toImpl(pageRef)->inspector());
>+    return toAPI(WebKit::toImpl(pageRef)->inspector());
> }
> 
> double WKPageGetEstimatedProgress(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->estimatedProgress();
>+    return WebKit::toImpl(pageRef)->estimatedProgress();
> }
> 
> WKStringRef WKPageCopyUserAgent(WKPageRef pageRef)
> {
>-    return toCopiedAPI(toImpl(pageRef)->userAgent());
>+    return toCopiedAPI(WebKit::toImpl(pageRef)->userAgent());
> }
> 
> WKStringRef WKPageCopyApplicationNameForUserAgent(WKPageRef pageRef)
> {
>-    return toCopiedAPI(toImpl(pageRef)->applicationNameForUserAgent());
>+    return toCopiedAPI(WebKit::toImpl(pageRef)->applicationNameForUserAgent());
> }
> 
> void WKPageSetApplicationNameForUserAgent(WKPageRef pageRef, WKStringRef applicationNameRef)
> {
>-    toImpl(pageRef)->setApplicationNameForUserAgent(toWTFString(applicationNameRef));
>+    WebKit::toImpl(pageRef)->setApplicationNameForUserAgent(toWTFString(applicationNameRef));
> }
> 
> WKStringRef WKPageCopyCustomUserAgent(WKPageRef pageRef)
> {
>-    return toCopiedAPI(toImpl(pageRef)->customUserAgent());
>+    return toCopiedAPI(WebKit::toImpl(pageRef)->customUserAgent());
> }
> 
> void WKPageSetCustomUserAgent(WKPageRef pageRef, WKStringRef userAgentRef)
> {
>-    toImpl(pageRef)->setCustomUserAgent(toWTFString(userAgentRef));
>+    WebKit::toImpl(pageRef)->setCustomUserAgent(toWTFString(userAgentRef));
> }
> 
> void WKPageSetUserContentExtensionsEnabled(WKPageRef pageRef, bool enabled)
>@@ -422,22 +422,22 @@ void WKPageSetUserContentExtensionsEnabled(WKPageRef pageRef, bool enabled)
> 
> bool WKPageSupportsTextEncoding(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->supportsTextEncoding();
>+    return WebKit::toImpl(pageRef)->supportsTextEncoding();
> }
> 
> WKStringRef WKPageCopyCustomTextEncodingName(WKPageRef pageRef)
> {
>-    return toCopiedAPI(toImpl(pageRef)->customTextEncodingName());
>+    return toCopiedAPI(WebKit::toImpl(pageRef)->customTextEncodingName());
> }
> 
> void WKPageSetCustomTextEncodingName(WKPageRef pageRef, WKStringRef encodingNameRef)
> {
>-    toImpl(pageRef)->setCustomTextEncodingName(toWTFString(encodingNameRef));
>+    WebKit::toImpl(pageRef)->setCustomTextEncodingName(toWTFString(encodingNameRef));
> }
> 
> void WKPageTerminate(WKPageRef pageRef)
> {
>-    Ref<WebProcessProxy> protectedProcessProxy(toImpl(pageRef)->process());
>+    Ref<WebProcessProxy> protectedProcessProxy(WebKit::toImpl(pageRef)->process());
>     protectedProcessProxy->requestTermination(ProcessTerminationReason::RequestedByClient);
> }
> 
>@@ -459,7 +459,7 @@ WKTypeRef WKPageCopySessionState(WKPageRef pageRef, void* context, WKPageSession
>     bool shouldReturnData = !(reinterpret_cast<uintptr_t>(context) & 1);
>     context = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(context) & ~1);
> 
>-    auto sessionState = toImpl(pageRef)->sessionState([pageRef, context, filter](WebBackForwardListItem& item) {
>+    auto sessionState = WebKit::toImpl(pageRef)->sessionState([pageRef, context, filter](WebBackForwardListItem& item) {
>         if (filter) {
>             if (!filter(pageRef, WKPageGetSessionBackForwardListItemValueType(), toAPI(&item), context))
>                 return false;
>@@ -482,16 +482,16 @@ static void restoreFromSessionState(WKPageRef pageRef, WKTypeRef sessionStateRef
>     SessionState sessionState;
> 
>     // FIXME: This is for backwards compatibility with Safari. Remove it once Safari no longer depends on it.
>-    if (toImpl(sessionStateRef)->type() == API::Object::Type::Data) {
>-        if (!decodeLegacySessionState(toImpl(static_cast<WKDataRef>(sessionStateRef))->bytes(), toImpl(static_cast<WKDataRef>(sessionStateRef))->size(), sessionState))
>+    if (WebKit::toImpl(sessionStateRef)->type() == API::Object::Type::Data) {
>+        if (!decodeLegacySessionState(WebKit::toImpl(static_cast<WKDataRef>(sessionStateRef))->bytes(), WebKit::toImpl(static_cast<WKDataRef>(sessionStateRef))->size(), sessionState))
>             return;
>     } else {
>-        ASSERT(toImpl(sessionStateRef)->type() == API::Object::Type::SessionState);
>+        ASSERT(WebKit::toImpl(sessionStateRef)->type() == API::Object::Type::SessionState);
> 
>-        sessionState = toImpl(static_cast<WKSessionStateRef>(sessionStateRef))->sessionState();
>+        sessionState = WebKit::toImpl(static_cast<WKSessionStateRef>(sessionStateRef))->sessionState();
>     }
> 
>-    toImpl(pageRef)->restoreFromSessionState(WTFMove(sessionState), navigate);
>+    WebKit::toImpl(pageRef)->restoreFromSessionState(WTFMove(sessionState), navigate);
> }
> 
> void WKPageRestoreFromSessionState(WKPageRef pageRef, WKTypeRef sessionStateRef)
>@@ -506,187 +506,187 @@ void WKPageRestoreFromSessionStateWithoutNavigation(WKPageRef pageRef, WKTypeRef
> 
> double WKPageGetTextZoomFactor(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->textZoomFactor();
>+    return WebKit::toImpl(pageRef)->textZoomFactor();
> }
> 
> double WKPageGetBackingScaleFactor(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->deviceScaleFactor();
>+    return WebKit::toImpl(pageRef)->deviceScaleFactor();
> }
> 
> void WKPageSetCustomBackingScaleFactor(WKPageRef pageRef, double customScaleFactor)
> {
>-    toImpl(pageRef)->setCustomDeviceScaleFactor(customScaleFactor);
>+    WebKit::toImpl(pageRef)->setCustomDeviceScaleFactor(customScaleFactor);
> }
> 
> bool WKPageSupportsTextZoom(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->supportsTextZoom();
>+    return WebKit::toImpl(pageRef)->supportsTextZoom();
> }
> 
> void WKPageSetTextZoomFactor(WKPageRef pageRef, double zoomFactor)
> {
>-    toImpl(pageRef)->setTextZoomFactor(zoomFactor);
>+    WebKit::toImpl(pageRef)->setTextZoomFactor(zoomFactor);
> }
> 
> double WKPageGetPageZoomFactor(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->pageZoomFactor();
>+    return WebKit::toImpl(pageRef)->pageZoomFactor();
> }
> 
> void WKPageSetPageZoomFactor(WKPageRef pageRef, double zoomFactor)
> {
>-    toImpl(pageRef)->setPageZoomFactor(zoomFactor);
>+    WebKit::toImpl(pageRef)->setPageZoomFactor(zoomFactor);
> }
> 
> void WKPageSetPageAndTextZoomFactors(WKPageRef pageRef, double pageZoomFactor, double textZoomFactor)
> {
>-    toImpl(pageRef)->setPageAndTextZoomFactors(pageZoomFactor, textZoomFactor);
>+    WebKit::toImpl(pageRef)->setPageAndTextZoomFactors(pageZoomFactor, textZoomFactor);
> }
> 
> void WKPageSetScaleFactor(WKPageRef pageRef, double scale, WKPoint origin)
> {
>-    toImpl(pageRef)->scalePage(scale, toIntPoint(origin));
>+    WebKit::toImpl(pageRef)->scalePage(scale, toIntPoint(origin));
> }
> 
> double WKPageGetScaleFactor(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->pageScaleFactor();
>+    return WebKit::toImpl(pageRef)->pageScaleFactor();
> }
> 
> void WKPageSetUseFixedLayout(WKPageRef pageRef, bool fixed)
> {
>-    toImpl(pageRef)->setUseFixedLayout(fixed);
>+    WebKit::toImpl(pageRef)->setUseFixedLayout(fixed);
> }
> 
> void WKPageSetFixedLayoutSize(WKPageRef pageRef, WKSize size)
> {
>-    toImpl(pageRef)->setFixedLayoutSize(toIntSize(size));
>+    WebKit::toImpl(pageRef)->setFixedLayoutSize(toIntSize(size));
> }
> 
> bool WKPageUseFixedLayout(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->useFixedLayout();
>+    return WebKit::toImpl(pageRef)->useFixedLayout();
> }
> 
> WKSize WKPageFixedLayoutSize(WKPageRef pageRef)
> {
>-    return toAPI(toImpl(pageRef)->fixedLayoutSize());
>+    return toAPI(WebKit::toImpl(pageRef)->fixedLayoutSize());
> }
> 
> void WKPageListenForLayoutMilestones(WKPageRef pageRef, WKLayoutMilestones milestones)
> {
>-    toImpl(pageRef)->listenForLayoutMilestones(toLayoutMilestones(milestones));
>+    WebKit::toImpl(pageRef)->listenForLayoutMilestones(toLayoutMilestones(milestones));
> }
> 
> bool WKPageHasHorizontalScrollbar(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->hasHorizontalScrollbar();
>+    return WebKit::toImpl(pageRef)->hasHorizontalScrollbar();
> }
> 
> bool WKPageHasVerticalScrollbar(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->hasVerticalScrollbar();
>+    return WebKit::toImpl(pageRef)->hasVerticalScrollbar();
> }
> 
> void WKPageSetSuppressScrollbarAnimations(WKPageRef pageRef, bool suppressAnimations)
> {
>-    toImpl(pageRef)->setSuppressScrollbarAnimations(suppressAnimations);
>+    WebKit::toImpl(pageRef)->setSuppressScrollbarAnimations(suppressAnimations);
> }
> 
> bool WKPageAreScrollbarAnimationsSuppressed(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->areScrollbarAnimationsSuppressed();
>+    return WebKit::toImpl(pageRef)->areScrollbarAnimationsSuppressed();
> }
> 
> bool WKPageIsPinnedToLeftSide(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->isPinnedToLeftSide();
>+    return WebKit::toImpl(pageRef)->isPinnedToLeftSide();
> }
> 
> bool WKPageIsPinnedToRightSide(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->isPinnedToRightSide();
>+    return WebKit::toImpl(pageRef)->isPinnedToRightSide();
> }
> 
> bool WKPageIsPinnedToTopSide(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->isPinnedToTopSide();
>+    return WebKit::toImpl(pageRef)->isPinnedToTopSide();
> }
> 
> bool WKPageIsPinnedToBottomSide(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->isPinnedToBottomSide();
>+    return WebKit::toImpl(pageRef)->isPinnedToBottomSide();
> }
> 
> bool WKPageRubberBandsAtLeft(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->rubberBandsAtLeft();
>+    return WebKit::toImpl(pageRef)->rubberBandsAtLeft();
> }
> 
> void WKPageSetRubberBandsAtLeft(WKPageRef pageRef, bool rubberBandsAtLeft)
> {
>-    toImpl(pageRef)->setRubberBandsAtLeft(rubberBandsAtLeft);
>+    WebKit::toImpl(pageRef)->setRubberBandsAtLeft(rubberBandsAtLeft);
> }
> 
> bool WKPageRubberBandsAtRight(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->rubberBandsAtRight();
>+    return WebKit::toImpl(pageRef)->rubberBandsAtRight();
> }
> 
> void WKPageSetRubberBandsAtRight(WKPageRef pageRef, bool rubberBandsAtRight)
> {
>-    toImpl(pageRef)->setRubberBandsAtRight(rubberBandsAtRight);
>+    WebKit::toImpl(pageRef)->setRubberBandsAtRight(rubberBandsAtRight);
> }
> 
> bool WKPageRubberBandsAtTop(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->rubberBandsAtTop();
>+    return WebKit::toImpl(pageRef)->rubberBandsAtTop();
> }
> 
> void WKPageSetRubberBandsAtTop(WKPageRef pageRef, bool rubberBandsAtTop)
> {
>-    toImpl(pageRef)->setRubberBandsAtTop(rubberBandsAtTop);
>+    WebKit::toImpl(pageRef)->setRubberBandsAtTop(rubberBandsAtTop);
> }
> 
> bool WKPageRubberBandsAtBottom(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->rubberBandsAtBottom();
>+    return WebKit::toImpl(pageRef)->rubberBandsAtBottom();
> }
> 
> void WKPageSetRubberBandsAtBottom(WKPageRef pageRef, bool rubberBandsAtBottom)
> {
>-    toImpl(pageRef)->setRubberBandsAtBottom(rubberBandsAtBottom);
>+    WebKit::toImpl(pageRef)->setRubberBandsAtBottom(rubberBandsAtBottom);
> }
> 
> bool WKPageVerticalRubberBandingIsEnabled(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->verticalRubberBandingIsEnabled();
>+    return WebKit::toImpl(pageRef)->verticalRubberBandingIsEnabled();
> }
> 
> void WKPageSetEnableVerticalRubberBanding(WKPageRef pageRef, bool enableVerticalRubberBanding)
> {
>-    toImpl(pageRef)->setEnableVerticalRubberBanding(enableVerticalRubberBanding);
>+    WebKit::toImpl(pageRef)->setEnableVerticalRubberBanding(enableVerticalRubberBanding);
> }
> 
> bool WKPageHorizontalRubberBandingIsEnabled(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->horizontalRubberBandingIsEnabled();
>+    return WebKit::toImpl(pageRef)->horizontalRubberBandingIsEnabled();
> }
> 
> void WKPageSetEnableHorizontalRubberBanding(WKPageRef pageRef, bool enableHorizontalRubberBanding)
> {
>-    toImpl(pageRef)->setEnableHorizontalRubberBanding(enableHorizontalRubberBanding);
>+    WebKit::toImpl(pageRef)->setEnableHorizontalRubberBanding(enableHorizontalRubberBanding);
> }
> 
> void WKPageSetBackgroundExtendsBeyondPage(WKPageRef pageRef, bool backgroundExtendsBeyondPage)
> {
>-    toImpl(pageRef)->setBackgroundExtendsBeyondPage(backgroundExtendsBeyondPage);
>+    WebKit::toImpl(pageRef)->setBackgroundExtendsBeyondPage(backgroundExtendsBeyondPage);
> }
> 
> bool WKPageBackgroundExtendsBeyondPage(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->backgroundExtendsBeyondPage();
>+    return WebKit::toImpl(pageRef)->backgroundExtendsBeyondPage();
> }
> 
> void WKPageSetPaginationMode(WKPageRef pageRef, WKPaginationMode paginationMode)
>@@ -711,12 +711,12 @@ void WKPageSetPaginationMode(WKPageRef pageRef, WKPaginationMode paginationMode)
>     default:
>         return;
>     }
>-    toImpl(pageRef)->setPaginationMode(mode);
>+    WebKit::toImpl(pageRef)->setPaginationMode(mode);
> }
> 
> WKPaginationMode WKPageGetPaginationMode(WKPageRef pageRef)
> {
>-    switch (toImpl(pageRef)->paginationMode()) {
>+    switch (WebKit::toImpl(pageRef)->paginationMode()) {
>     case Pagination::Unpaginated:
>         return kWKPaginationModeUnpaginated;
>     case Pagination::LeftToRightPaginated:
>@@ -735,102 +735,102 @@ WKPaginationMode WKPageGetPaginationMode(WKPageRef pageRef)
> 
> void WKPageSetPaginationBehavesLikeColumns(WKPageRef pageRef, bool behavesLikeColumns)
> {
>-    toImpl(pageRef)->setPaginationBehavesLikeColumns(behavesLikeColumns);
>+    WebKit::toImpl(pageRef)->setPaginationBehavesLikeColumns(behavesLikeColumns);
> }
> 
> bool WKPageGetPaginationBehavesLikeColumns(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->paginationBehavesLikeColumns();
>+    return WebKit::toImpl(pageRef)->paginationBehavesLikeColumns();
> }
> 
> void WKPageSetPageLength(WKPageRef pageRef, double pageLength)
> {
>-    toImpl(pageRef)->setPageLength(pageLength);
>+    WebKit::toImpl(pageRef)->setPageLength(pageLength);
> }
> 
> double WKPageGetPageLength(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->pageLength();
>+    return WebKit::toImpl(pageRef)->pageLength();
> }
> 
> void WKPageSetGapBetweenPages(WKPageRef pageRef, double gap)
> {
>-    toImpl(pageRef)->setGapBetweenPages(gap);
>+    WebKit::toImpl(pageRef)->setGapBetweenPages(gap);
> }
> 
> double WKPageGetGapBetweenPages(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->gapBetweenPages();
>+    return WebKit::toImpl(pageRef)->gapBetweenPages();
> }
> 
> void WKPageSetPaginationLineGridEnabled(WKPageRef pageRef, bool lineGridEnabled)
> {
>-    toImpl(pageRef)->setPaginationLineGridEnabled(lineGridEnabled);
>+    WebKit::toImpl(pageRef)->setPaginationLineGridEnabled(lineGridEnabled);
> }
> 
> bool WKPageGetPaginationLineGridEnabled(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->paginationLineGridEnabled();
>+    return WebKit::toImpl(pageRef)->paginationLineGridEnabled();
> }
> 
> unsigned WKPageGetPageCount(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->pageCount();
>+    return WebKit::toImpl(pageRef)->pageCount();
> }
> 
> bool WKPageCanDelete(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->canDelete();
>+    return WebKit::toImpl(pageRef)->canDelete();
> }
> 
> bool WKPageHasSelectedRange(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->hasSelectedRange();
>+    return WebKit::toImpl(pageRef)->hasSelectedRange();
> }
> 
> bool WKPageIsContentEditable(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->isContentEditable();
>+    return WebKit::toImpl(pageRef)->isContentEditable();
> }
> 
> void WKPageSetMaintainsInactiveSelection(WKPageRef pageRef, bool newValue)
> {
>-    return toImpl(pageRef)->setMaintainsInactiveSelection(newValue);
>+    return WebKit::toImpl(pageRef)->setMaintainsInactiveSelection(newValue);
> }
> 
> void WKPageCenterSelectionInVisibleArea(WKPageRef pageRef)
> {
>-    return toImpl(pageRef)->centerSelectionInVisibleArea();
>+    return WebKit::toImpl(pageRef)->centerSelectionInVisibleArea();
> }
> 
> void WKPageFindStringMatches(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
> {
>-    toImpl(pageRef)->findStringMatches(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
>+    WebKit::toImpl(pageRef)->findStringMatches(WebKit::toImpl(string)->string(), toFindOptions(options), maxMatchCount);
> }
> 
> void WKPageGetImageForFindMatch(WKPageRef pageRef, int32_t matchIndex)
> {
>-    toImpl(pageRef)->getImageForFindMatch(matchIndex);
>+    WebKit::toImpl(pageRef)->getImageForFindMatch(matchIndex);
> }
> 
> void WKPageSelectFindMatch(WKPageRef pageRef, int32_t matchIndex)
> {
>-    toImpl(pageRef)->selectFindMatch(matchIndex);
>+    WebKit::toImpl(pageRef)->selectFindMatch(matchIndex);
> }
> 
> void WKPageFindString(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
> {
>-    toImpl(pageRef)->findString(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
>+    WebKit::toImpl(pageRef)->findString(WebKit::toImpl(string)->string(), toFindOptions(options), maxMatchCount);
> }
> 
> void WKPageHideFindUI(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->hideFindUI();
>+    WebKit::toImpl(pageRef)->hideFindUI();
> }
> 
> void WKPageCountStringMatches(WKPageRef pageRef, WKStringRef string, WKFindOptions options, unsigned maxMatchCount)
> {
>-    toImpl(pageRef)->countStringMatches(toImpl(string)->string(), toFindOptions(options), maxMatchCount);
>+    WebKit::toImpl(pageRef)->countStringMatches(WebKit::toImpl(string)->string(), toFindOptions(options), maxMatchCount);
> }
> 
> void WKPageSetPageContextMenuClient(WKPageRef pageRef, const WKPageContextMenuClientBase* wkClient)
>@@ -881,7 +881,7 @@ void WKPageSetPageContextMenuClient(WKPageRef pageRef, const WKPageContextMenuCl
>             } else
>                 m_client.getContextMenuFromProposedMenu_deprecatedForUseWithV0(toAPI(&page), toAPI(API::Array::create(WTFMove(proposedMenuItems)).ptr()), &newMenu, toAPI(userData), m_client.base.clientInfo);
> 
>-            RefPtr<API::Array> array = adoptRef(toImpl(newMenu));
>+            RefPtr<API::Array> array = adoptRef(WebKit::toImpl(newMenu));
> 
>             Vector<Ref<WebContextMenuItem>> customMenu;
>             size_t newSize = array ? array->size() : 0;
>@@ -934,7 +934,7 @@ void WKPageSetPageContextMenuClient(WKPageRef pageRef, const WKPageContextMenuCl
>         }
>     };
> 
>-    toImpl(pageRef)->setContextMenuClient(std::make_unique<ContextMenuClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setContextMenuClient(std::make_unique<ContextMenuClient>(wkClient));
> #else
>     UNUSED_PARAM(pageRef);
>     UNUSED_PARAM(wkClient);
>@@ -943,7 +943,7 @@ void WKPageSetPageContextMenuClient(WKPageRef pageRef, const WKPageContextMenuCl
> 
> void WKPageSetPageDiagnosticLoggingClient(WKPageRef pageRef, const WKPageDiagnosticLoggingClientBase* wkClient)
> {
>-    toImpl(pageRef)->setDiagnosticLoggingClient(std::make_unique<WebPageDiagnosticLoggingClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setDiagnosticLoggingClient(std::make_unique<WebPageDiagnosticLoggingClient>(wkClient));
> }
> 
> void WKPageSetPageFindClient(WKPageRef pageRef, const WKPageFindClientBase* wkClient)
>@@ -981,7 +981,7 @@ void WKPageSetPageFindClient(WKPageRef pageRef, const WKPageFindClientBase* wkCl
>         }
>     };
> 
>-    toImpl(pageRef)->setFindClient(std::make_unique<FindClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setFindClient(std::make_unique<FindClient>(wkClient));
> }
> 
> void WKPageSetPageFindMatchesClient(WKPageRef pageRef, const WKPageFindMatchesClientBase* wkClient)
>@@ -1024,17 +1024,17 @@ void WKPageSetPageFindMatchesClient(WKPageRef pageRef, const WKPageFindMatchesCl
>         }
>     };
> 
>-    toImpl(pageRef)->setFindMatchesClient(std::make_unique<FindMatchesClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setFindMatchesClient(std::make_unique<FindMatchesClient>(wkClient));
> }
> 
> void WKPageSetPageInjectedBundleClient(WKPageRef pageRef, const WKPageInjectedBundleClientBase* wkClient)
> {
>-    toImpl(pageRef)->setInjectedBundleClient(wkClient);
>+    WebKit::toImpl(pageRef)->setInjectedBundleClient(wkClient);
> }
> 
> void WKPageSetPageFormClient(WKPageRef pageRef, const WKPageFormClientBase* wkClient)
> {
>-    toImpl(pageRef)->setFormClient(std::make_unique<WebFormClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setFormClient(std::make_unique<WebFormClient>(wkClient));
> }
> 
> void WKPageSetPageLoaderClient(WKPageRef pageRef, const WKPageLoaderClientBase* wkClient)
>@@ -1183,7 +1183,7 @@ void WKPageSetPageLoaderClient(WKPageRef pageRef, const WKPageLoaderClientBase*
>         }
>     };
> 
>-    WebPageProxy* webPageProxy = toImpl(pageRef);
>+    WebPageProxy* webPageProxy = WebKit::toImpl(pageRef);
> 
>     auto loaderClient = std::make_unique<LoaderClient>(wkClient);
> 
>@@ -1267,7 +1267,7 @@ void WKPageSetPagePolicyClient(WKPageRef pageRef, const WKPagePolicyClientBase*
>         }
>     };
> 
>-    toImpl(pageRef)->setPolicyClient(std::make_unique<PolicyClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setPolicyClient(std::make_unique<PolicyClient>(wkClient));
> }
> 
> namespace WebKit {
>@@ -1412,7 +1412,7 @@ WKTypeID WKPageRunBeforeUnloadConfirmPanelResultListenerGetTypeID()
> 
> void WKPageRunBeforeUnloadConfirmPanelResultListenerCall(WKPageRunBeforeUnloadConfirmPanelResultListenerRef listener, bool result)
> {
>-    toImpl(listener)->call(result);
>+    WebKit::toImpl(listener)->call(result);
> }
> 
> WKTypeID WKPageRunJavaScriptAlertResultListenerGetTypeID()
>@@ -1422,7 +1422,7 @@ WKTypeID WKPageRunJavaScriptAlertResultListenerGetTypeID()
> 
> void WKPageRunJavaScriptAlertResultListenerCall(WKPageRunJavaScriptAlertResultListenerRef listener)
> {
>-    toImpl(listener)->call();
>+    WebKit::toImpl(listener)->call();
> }
> 
> WKTypeID WKPageRunJavaScriptConfirmResultListenerGetTypeID()
>@@ -1432,7 +1432,7 @@ WKTypeID WKPageRunJavaScriptConfirmResultListenerGetTypeID()
> 
> void WKPageRunJavaScriptConfirmResultListenerCall(WKPageRunJavaScriptConfirmResultListenerRef listener, bool result)
> {
>-    toImpl(listener)->call(result);
>+    WebKit::toImpl(listener)->call(result);
> }
> 
> WKTypeID WKPageRunJavaScriptPromptResultListenerGetTypeID()
>@@ -1442,7 +1442,7 @@ WKTypeID WKPageRunJavaScriptPromptResultListenerGetTypeID()
> 
> void WKPageRunJavaScriptPromptResultListenerCall(WKPageRunJavaScriptPromptResultListenerRef listener, WKStringRef result)
> {
>-    toImpl(listener)->call(toWTFString(result));
>+    WebKit::toImpl(listener)->call(toWTFString(result));
> }
> 
> WKTypeID WKPageRequestStorageAccessConfirmResultListenerGetTypeID()
>@@ -1452,7 +1452,7 @@ WKTypeID WKPageRequestStorageAccessConfirmResultListenerGetTypeID()
> 
> void WKPageRequestStorageAccessConfirmResultListenerCall(WKPageRequestStorageAccessConfirmResultListenerRef listener, bool result)
> {
>-    toImpl(listener)->call(result);
>+    WebKit::toImpl(listener)->call(result);
> }
> 
> void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClientBase* wkClient)
>@@ -1477,7 +1477,7 @@ void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClientBase* wkClient
> 
>                 auto apiWindowFeatures = API::WindowFeatures::create(windowFeatures);
> 
>-                return completionHandler(adoptRef(toImpl(m_client.createNewPage(toAPI(&page), toAPI(configuration.ptr()), toAPI(apiNavigationAction.ptr()), toAPI(apiWindowFeatures.ptr()), m_client.base.clientInfo))));
>+                return completionHandler(adoptRef(WebKit::toImpl(m_client.createNewPage(toAPI(&page), toAPI(configuration.ptr()), toAPI(apiNavigationAction.ptr()), toAPI(apiWindowFeatures.ptr()), m_client.base.clientInfo))));
>             }
>         
>             if (m_client.createNewPage_deprecatedForUseWithV1 || m_client.createNewPage_deprecatedForUseWithV0) {
>@@ -1502,11 +1502,11 @@ void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClientBase* wkClient
> 
>                 if (m_client.createNewPage_deprecatedForUseWithV1) {
>                     Ref<API::URLRequest> request = API::URLRequest::create(resourceRequest);
>-                    return completionHandler(adoptRef(toImpl(m_client.createNewPage_deprecatedForUseWithV1(toAPI(&page), toAPI(request.ptr()), toAPI(featuresMap.ptr()), toAPI(navigationActionData.modifiers), toAPI(navigationActionData.mouseButton), m_client.base.clientInfo))));
>+                    return completionHandler(adoptRef(WebKit::toImpl(m_client.createNewPage_deprecatedForUseWithV1(toAPI(&page), toAPI(request.ptr()), toAPI(featuresMap.ptr()), toAPI(navigationActionData.modifiers), toAPI(navigationActionData.mouseButton), m_client.base.clientInfo))));
>                 }
>     
>                 ASSERT(m_client.createNewPage_deprecatedForUseWithV0);
>-                return completionHandler(adoptRef(toImpl(m_client.createNewPage_deprecatedForUseWithV0(toAPI(&page), toAPI(featuresMap.ptr()), toAPI(navigationActionData.modifiers), toAPI(navigationActionData.mouseButton), m_client.base.clientInfo))));
>+                return completionHandler(adoptRef(WebKit::toImpl(m_client.createNewPage_deprecatedForUseWithV0(toAPI(&page), toAPI(featuresMap.ptr()), toAPI(navigationActionData.modifiers), toAPI(navigationActionData.mouseButton), m_client.base.clientInfo))));
>             }
> 
>             completionHandler(nullptr);
>@@ -1640,7 +1640,7 @@ void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClientBase* wkClient
> 
>             if (m_client.runJavaScriptPrompt_deprecatedForUseWithV5) {
>                 RefPtr<API::SecurityOrigin> securityOrigin = API::SecurityOrigin::create(securityOriginData.protocol, securityOriginData.host, securityOriginData.port);
>-                RefPtr<API::String> string = adoptRef(toImpl(m_client.runJavaScriptPrompt_deprecatedForUseWithV5(toAPI(page), toAPI(message.impl()), toAPI(defaultValue.impl()), toAPI(frame), toAPI(securityOrigin.get()), m_client.base.clientInfo)));
>+                RefPtr<API::String> string = adoptRef(WebKit::toImpl(m_client.runJavaScriptPrompt_deprecatedForUseWithV5(toAPI(page), toAPI(message.impl()), toAPI(defaultValue.impl()), toAPI(frame), toAPI(securityOrigin.get()), m_client.base.clientInfo)));
>                 
>                 if (string)
>                     completionHandler(string->string());
>@@ -1650,7 +1650,7 @@ void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClientBase* wkClient
>             }
>             
>             if (m_client.runJavaScriptPrompt_deprecatedForUseWithV0) {
>-                RefPtr<API::String> string = adoptRef(toImpl(m_client.runJavaScriptPrompt_deprecatedForUseWithV0(toAPI(page), toAPI(message.impl()), toAPI(defaultValue.impl()), toAPI(frame), m_client.base.clientInfo)));
>+                RefPtr<API::String> string = adoptRef(WebKit::toImpl(m_client.runJavaScriptPrompt_deprecatedForUseWithV0(toAPI(page), toAPI(message.impl()), toAPI(defaultValue.impl()), toAPI(frame), m_client.base.clientInfo)));
>                 
>                 if (string)
>                     completionHandler(string->string());
>@@ -2046,7 +2046,7 @@ void WKPageSetPageUIClient(WKPageRef pageRef, const WKPageUIClientBase* wkClient
>         }
>     };
> 
>-    toImpl(pageRef)->setUIClient(std::make_unique<UIClient>(wkClient));
>+    WebKit::toImpl(pageRef)->setUIClient(std::make_unique<UIClient>(wkClient));
> }
> 
> void WKPageSetPageNavigationClient(WKPageRef pageRef, const WKPageNavigationClientBase* wkClient)
>@@ -2174,7 +2174,7 @@ void WKPageSetPageNavigationClient(WKPageRef pageRef, const WKPageNavigationClie
>         RefPtr<API::Data> webCryptoMasterKey(WebPageProxy& page) override
>         {
>             if (m_client.copyWebCryptoMasterKey)
>-                return adoptRef(toImpl(m_client.copyWebCryptoMasterKey(toAPI(&page), m_client.base.clientInfo)));
>+                return adoptRef(WebKit::toImpl(m_client.copyWebCryptoMasterKey(toAPI(&page), m_client.base.clientInfo)));
> 
>             Vector<uint8_t> masterKey;
> #if ENABLE(WEB_CRYPTO)
>@@ -2188,7 +2188,7 @@ void WKPageSetPageNavigationClient(WKPageRef pageRef, const WKPageNavigationClie
>         RefPtr<API::String> signedPublicKeyAndChallengeString(WebPageProxy& page, unsigned keySizeIndex, const RefPtr<API::String>& challengeString, const URL& url) override
>         {
>             if (m_client.copySignedPublicKeyAndChallengeString)
>-                return adoptRef(toImpl(m_client.copySignedPublicKeyAndChallengeString(toAPI(&page), m_client.base.clientInfo)));
>+                return adoptRef(WebKit::toImpl(m_client.copySignedPublicKeyAndChallengeString(toAPI(&page), m_client.base.clientInfo)));
>             return API::String::create(WebCore::signedPublicKeyAndChallengeString(keySizeIndex, challengeString->string(), url));
>         }
> 
>@@ -2246,7 +2246,7 @@ void WKPageSetPageNavigationClient(WKPageRef pageRef, const WKPageNavigationClie
>             
>             String unavailabilityDescription;
>             if (unavailabilityDescriptionOut) {
>-                RefPtr<API::String> webUnavailabilityDescription = adoptRef(toImpl(unavailabilityDescriptionOut));
>+                RefPtr<API::String> webUnavailabilityDescription = adoptRef(WebKit::toImpl(unavailabilityDescriptionOut));
>                 unavailabilityDescription = webUnavailabilityDescription->string();
>             }
>             
>@@ -2255,14 +2255,14 @@ void WKPageSetPageNavigationClient(WKPageRef pageRef, const WKPageNavigationClie
> #endif
>     };
> 
>-    WebPageProxy* webPageProxy = toImpl(pageRef);
>+    WebPageProxy* webPageProxy = WebKit::toImpl(pageRef);
> 
>     webPageProxy->setNavigationClient(makeUniqueRef<NavigationClient>(wkClient));
> }
> 
> void WKPageRunJavaScriptInMainFrame(WKPageRef pageRef, WKStringRef scriptRef, void* context, WKPageRunJavaScriptFunction callback)
> {
>-    toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), true, [context, callback](API::SerializedScriptValue* returnValue, bool, const WebCore::ExceptionDetails&, CallbackBase::Error error) {
>+    WebKit::toImpl(pageRef)->runJavaScriptInMainFrame(WebKit::toImpl(scriptRef)->string(), true, [context, callback](API::SerializedScriptValue* returnValue, bool, const WebCore::ExceptionDetails&, CallbackBase::Error error) {
>         callback(toAPI(returnValue), (error != CallbackBase::Error::None) ? toAPI(API::Error::create().ptr()) : 0, context);
>     });
> }
>@@ -2290,45 +2290,45 @@ static WTF::Function<void (const String&, WebKit::CallbackBase::Error)> toGeneri
> 
> void WKPageRenderTreeExternalRepresentation(WKPageRef pageRef, void* context, WKPageRenderTreeExternalRepresentationFunction callback)
> {
>-    toImpl(pageRef)->getRenderTreeExternalRepresentation(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getRenderTreeExternalRepresentation(toGenericCallbackFunction(context, callback));
> }
> 
> void WKPageGetSourceForFrame(WKPageRef pageRef, WKFrameRef frameRef, void* context, WKPageGetSourceForFrameFunction callback)
> {
>-    toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getSourceForFrame(WebKit::toImpl(frameRef), toGenericCallbackFunction(context, callback));
> }
> 
> void WKPageGetContentsAsString(WKPageRef pageRef, void* context, WKPageGetContentsAsStringFunction callback)
> {
>-    toImpl(pageRef)->getContentsAsString(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getContentsAsString(toGenericCallbackFunction(context, callback));
> }
> 
> void WKPageGetBytecodeProfile(WKPageRef pageRef, void* context, WKPageGetBytecodeProfileFunction callback)
> {
>-    toImpl(pageRef)->getBytecodeProfile(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getBytecodeProfile(toGenericCallbackFunction(context, callback));
> }
> 
> void WKPageGetSamplingProfilerOutput(WKPageRef pageRef, void* context, WKPageGetSamplingProfilerOutputFunction callback)
> {
>-    toImpl(pageRef)->getSamplingProfilerOutput(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getSamplingProfilerOutput(toGenericCallbackFunction(context, callback));
> }
> 
> void WKPageIsWebProcessResponsive(WKPageRef pageRef, void* context, WKPageIsWebProcessResponsiveFunction callback)
> {
>-    toImpl(pageRef)->isWebProcessResponsive([context, callback](bool isWebProcessResponsive) {
>+    WebKit::toImpl(pageRef)->isWebProcessResponsive([context, callback](bool isWebProcessResponsive) {
>         callback(isWebProcessResponsive, context);
>     });
> }
> 
> void WKPageGetSelectionAsWebArchiveData(WKPageRef pageRef, void* context, WKPageGetSelectionAsWebArchiveDataFunction callback)
> {
>-    toImpl(pageRef)->getSelectionAsWebArchiveData(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getSelectionAsWebArchiveData(toGenericCallbackFunction(context, callback));
> }
> 
> void WKPageGetContentsAsMHTMLData(WKPageRef pageRef, void* context, WKPageGetContentsAsMHTMLDataFunction callback)
> {
> #if ENABLE(MHTML)
>-    toImpl(pageRef)->getContentsAsMHTMLData(toGenericCallbackFunction(context, callback));
>+    WebKit::toImpl(pageRef)->getContentsAsMHTMLData(toGenericCallbackFunction(context, callback));
> #else
>     UNUSED_PARAM(pageRef);
>     UNUSED_PARAM(context);
>@@ -2338,14 +2338,14 @@ void WKPageGetContentsAsMHTMLData(WKPageRef pageRef, void* context, WKPageGetCon
> 
> void WKPageForceRepaint(WKPageRef pageRef, void* context, WKPageForceRepaintFunction callback)
> {
>-    toImpl(pageRef)->forceRepaint(VoidCallback::create([context, callback](WebKit::CallbackBase::Error error) {
>+    WebKit::toImpl(pageRef)->forceRepaint(VoidCallback::create([context, callback](WebKit::CallbackBase::Error error) {
>         callback(error == WebKit::CallbackBase::Error::None ? nullptr : toAPI(API::Error::create().ptr()), context);
>     }));
> }
> 
> WK_EXPORT WKURLRef WKPageCopyPendingAPIRequestURL(WKPageRef pageRef)
> {
>-    const String& pendingAPIRequestURL = toImpl(pageRef)->pageLoadState().pendingAPIRequestURL();
>+    const String& pendingAPIRequestURL = WebKit::toImpl(pageRef)->pageLoadState().pendingAPIRequestURL();
> 
>     if (pendingAPIRequestURL.isNull())
>         return nullptr;
>@@ -2355,34 +2355,34 @@ WK_EXPORT WKURLRef WKPageCopyPendingAPIRequestURL(WKPageRef pageRef)
> 
> WKURLRef WKPageCopyActiveURL(WKPageRef pageRef)
> {
>-    return toCopiedURLAPI(toImpl(pageRef)->pageLoadState().activeURL());
>+    return toCopiedURLAPI(WebKit::toImpl(pageRef)->pageLoadState().activeURL());
> }
> 
> WKURLRef WKPageCopyProvisionalURL(WKPageRef pageRef)
> {
>-    return toCopiedURLAPI(toImpl(pageRef)->pageLoadState().provisionalURL());
>+    return toCopiedURLAPI(WebKit::toImpl(pageRef)->pageLoadState().provisionalURL());
> }
> 
> WKURLRef WKPageCopyCommittedURL(WKPageRef pageRef)
> {
>-    return toCopiedURLAPI(toImpl(pageRef)->pageLoadState().url());
>+    return toCopiedURLAPI(WebKit::toImpl(pageRef)->pageLoadState().url());
> }
> 
> WKStringRef WKPageCopyStandardUserAgentWithApplicationName(WKStringRef applicationName)
> {
>-    return toCopiedAPI(WebPageProxy::standardUserAgent(toImpl(applicationName)->string()));
>+    return toCopiedAPI(WebPageProxy::standardUserAgent(WebKit::toImpl(applicationName)->string()));
> }
> 
> void WKPageValidateCommand(WKPageRef pageRef, WKStringRef command, void* context, WKPageValidateCommandCallback callback)
> {
>-    toImpl(pageRef)->validateCommand(toImpl(command)->string(), [context, callback](const String& commandName, bool isEnabled, int32_t state, WebKit::CallbackBase::Error error) {
>+    WebKit::toImpl(pageRef)->validateCommand(WebKit::toImpl(command)->string(), [context, callback](const String& commandName, bool isEnabled, int32_t state, WebKit::CallbackBase::Error error) {
>         callback(toAPI(API::String::create(commandName).ptr()), isEnabled, state, error != WebKit::CallbackBase::Error::None ? toAPI(API::Error::create().ptr()) : 0, context);
>     });
> }
> 
> void WKPageExecuteCommand(WKPageRef pageRef, WKStringRef command)
> {
>-    toImpl(pageRef)->executeEditCommand(toImpl(command)->string());
>+    WebKit::toImpl(pageRef)->executeEditCommand(WebKit::toImpl(command)->string());
> }
> 
> #if PLATFORM(COCOA)
>@@ -2397,7 +2397,7 @@ static PrintInfo printInfoFromWKPrintInfo(const WKPrintInfo& printInfo)
> 
> void WKPageComputePagesForPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, WKPageComputePagesForPrintingFunction callback, void* context)
> {
>-    toImpl(page)->computePagesForPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo), ComputedPagesCallback::create([context, callback](const Vector<WebCore::IntRect>& rects, double scaleFactor, WebKit::CallbackBase::Error error) {
>+    WebKit::toImpl(page)->computePagesForPrinting(WebKit::toImpl(frame), printInfoFromWKPrintInfo(printInfo), ComputedPagesCallback::create([context, callback](const Vector<WebCore::IntRect>& rects, double scaleFactor, WebKit::CallbackBase::Error error) {
>         Vector<WKRect> wkRects(rects.size());
>         for (size_t i = 0; i < rects.size(); ++i)
>             wkRects[i] = toAPI(rects[i]);
>@@ -2407,34 +2407,34 @@ void WKPageComputePagesForPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo
> 
> void WKPageBeginPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo)
> {
>-    toImpl(page)->beginPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo));
>+    WebKit::toImpl(page)->beginPrinting(WebKit::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(toGenericCallbackFunction(context, callback)));
>+    WebKit::toImpl(page)->drawPagesToPDF(WebKit::toImpl(frame), printInfoFromWKPrintInfo(printInfo), first, count, DataCallback::create(toGenericCallbackFunction(context, callback)));
> }
> 
> void WKPageEndPrinting(WKPageRef page)
> {
>-    toImpl(page)->endPrinting();
>+    WebKit::toImpl(page)->endPrinting();
> }
> #endif
> 
> bool WKPageGetIsControlledByAutomation(WKPageRef page)
> {
>-    return toImpl(page)->isControlledByAutomation();
>+    return WebKit::toImpl(page)->isControlledByAutomation();
> }
> 
> void WKPageSetControlledByAutomation(WKPageRef page, bool controlled)
> {
>-    toImpl(page)->setControlledByAutomation(controlled);
>+    WebKit::toImpl(page)->setControlledByAutomation(controlled);
> }
> 
> bool WKPageGetAllowsRemoteInspection(WKPageRef page)
> {
> #if ENABLE(REMOTE_INSPECTOR)
>-    return toImpl(page)->allowsRemoteInspection();
>+    return WebKit::toImpl(page)->allowsRemoteInspection();
> #else
>     UNUSED_PARAM(page);
>     return false;
>@@ -2444,7 +2444,7 @@ bool WKPageGetAllowsRemoteInspection(WKPageRef page)
> void WKPageSetAllowsRemoteInspection(WKPageRef page, bool allow)
> {
> #if ENABLE(REMOTE_INSPECTOR)
>-    toImpl(page)->setAllowsRemoteInspection(allow);
>+    WebKit::toImpl(page)->setAllowsRemoteInspection(allow);
> #else
>     UNUSED_PARAM(page);
>     UNUSED_PARAM(allow);
>@@ -2453,28 +2453,28 @@ void WKPageSetAllowsRemoteInspection(WKPageRef page, bool allow)
> 
> void WKPageSetMediaVolume(WKPageRef page, float volume)
> {
>-    toImpl(page)->setMediaVolume(volume);    
>+    WebKit::toImpl(page)->setMediaVolume(volume);    
> }
> 
> void WKPageSetMuted(WKPageRef page, WKMediaMutedState muted)
> {
>-    toImpl(page)->setMuted(muted);
>+    WebKit::toImpl(page)->setMuted(muted);
> }
> 
> void WKPageSetMediaCaptureEnabled(WKPageRef page, bool enabled)
> {
>-    toImpl(page)->setMediaCaptureEnabled(enabled);
>+    WebKit::toImpl(page)->setMediaCaptureEnabled(enabled);
> }
> 
> bool WKPageGetMediaCaptureEnabled(WKPageRef page)
> {
>-    return toImpl(page)->mediaCaptureEnabled();
>+    return WebKit::toImpl(page)->mediaCaptureEnabled();
> }
> 
> void WKPageDidAllowPointerLock(WKPageRef page)
> {
> #if ENABLE(POINTER_LOCK)
>-    toImpl(page)->didAllowPointerLock();
>+    WebKit::toImpl(page)->didAllowPointerLock();
> #else
>     UNUSED_PARAM(page);
> #endif
>@@ -2483,7 +2483,7 @@ void WKPageDidAllowPointerLock(WKPageRef page)
> void WKPageClearUserMediaState(WKPageRef page)
> {
> #if ENABLE(MEDIA_STREAM)
>-    toImpl(page)->clearUserMediaState();
>+    WebKit::toImpl(page)->clearUserMediaState();
> #else
>     UNUSED_PARAM(page);
> #endif
>@@ -2492,7 +2492,7 @@ void WKPageClearUserMediaState(WKPageRef page)
> void WKPageDidDenyPointerLock(WKPageRef page)
> {
> #if ENABLE(POINTER_LOCK)
>-    toImpl(page)->didDenyPointerLock();
>+    WebKit::toImpl(page)->didDenyPointerLock();
> #else
>     UNUSED_PARAM(page);
> #endif
>@@ -2501,7 +2501,7 @@ void WKPageDidDenyPointerLock(WKPageRef page)
> bool WKPageHasMediaSessionWithActiveMediaElements(WKPageRef page)
> {
> #if ENABLE(MEDIA_SESSION)
>-    return toImpl(page)->hasMediaSessionWithActiveMediaElements();
>+    return WebKit::toImpl(page)->hasMediaSessionWithActiveMediaElements();
> #else
>     UNUSED_PARAM(page);
>     return false;
>@@ -2528,7 +2528,7 @@ void WKPageHandleMediaEvent(WKPageRef page, WKMediaEventType wkEventType)
>         return;
>     }
> 
>-    toImpl(page)->handleMediaEvent(eventType);
>+    WebKit::toImpl(page)->handleMediaEvent(eventType);
> #else
>     UNUSED_PARAM(page);
>     UNUSED_PARAM(wkEventType);
>@@ -2537,15 +2537,15 @@ void WKPageHandleMediaEvent(WKPageRef page, WKMediaEventType wkEventType)
> 
> void WKPagePostMessageToInjectedBundle(WKPageRef pageRef, WKStringRef messageNameRef, WKTypeRef messageBodyRef)
> {
>-    toImpl(pageRef)->postMessageToInjectedBundle(toImpl(messageNameRef)->string(), toImpl(messageBodyRef));
>+    WebKit::toImpl(pageRef)->postMessageToInjectedBundle(WebKit::toImpl(messageNameRef)->string(), WebKit::toImpl(messageBodyRef));
> }
> 
> WKArrayRef WKPageCopyRelatedPages(WKPageRef pageRef)
> {
>     Vector<RefPtr<API::Object>> relatedPages;
> 
>-    for (auto& page : toImpl(pageRef)->process().pages()) {
>-        if (page != toImpl(pageRef))
>+    for (auto& page : WebKit::toImpl(pageRef)->process().pages()) {
>+        if (page != WebKit::toImpl(pageRef))
>             relatedPages.append(page);
>     }
> 
>@@ -2554,8 +2554,8 @@ WKArrayRef WKPageCopyRelatedPages(WKPageRef pageRef)
> 
> WKFrameRef WKPageLookUpFrameFromHandle(WKPageRef pageRef, WKFrameHandleRef handleRef)
> {
>-    auto page = toImpl(pageRef);
>-    auto frame = page->process().webFrame(toImpl(handleRef)->frameID());
>+    auto page = WebKit::toImpl(pageRef);
>+    auto frame = page->process().webFrame(WebKit::toImpl(handleRef)->frameID());
>     if (!frame || frame->page() != page)
>         return nullptr;
> 
>@@ -2564,14 +2564,14 @@ WKFrameRef WKPageLookUpFrameFromHandle(WKPageRef pageRef, WKFrameHandleRef handl
> 
> void WKPageSetMayStartMediaWhenInWindow(WKPageRef pageRef, bool mayStartMedia)
> {
>-    toImpl(pageRef)->setMayStartMediaWhenInWindow(mayStartMedia);
>+    WebKit::toImpl(pageRef)->setMayStartMediaWhenInWindow(mayStartMedia);
> }
> 
> 
> void WKPageSelectContextMenuItem(WKPageRef page, WKContextMenuItemRef item)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    toImpl(page)->contextMenuItemSelected((toImpl(item)->data()));
>+    WebKit::toImpl(page)->contextMenuItemSelected((WebKit::toImpl(item)->data()));
> #else
>     UNUSED_PARAM(page);
>     UNUSED_PARAM(item);
>@@ -2580,7 +2580,7 @@ void WKPageSelectContextMenuItem(WKPageRef page, WKContextMenuItemRef item)
> 
> WKScrollPinningBehavior WKPageGetScrollPinningBehavior(WKPageRef page)
> {
>-    ScrollPinningBehavior pinning = toImpl(page)->scrollPinningBehavior();
>+    ScrollPinningBehavior pinning = WebKit::toImpl(page)->scrollPinningBehavior();
>     
>     switch (pinning) {
>     case WebCore::ScrollPinningBehavior::DoNotPin:
>@@ -2613,27 +2613,27 @@ void WKPageSetScrollPinningBehavior(WKPageRef page, WKScrollPinningBehavior pinn
>         ASSERT_NOT_REACHED();
>     }
>     
>-    toImpl(page)->setScrollPinningBehavior(corePinning);
>+    WebKit::toImpl(page)->setScrollPinningBehavior(corePinning);
> }
> 
> bool WKPageGetAddsVisitedLinks(WKPageRef page)
> {
>-    return toImpl(page)->addsVisitedLinks();
>+    return WebKit::toImpl(page)->addsVisitedLinks();
> }
> 
> void WKPageSetAddsVisitedLinks(WKPageRef page, bool addsVisitedLinks)
> {
>-    toImpl(page)->setAddsVisitedLinks(addsVisitedLinks);
>+    WebKit::toImpl(page)->setAddsVisitedLinks(addsVisitedLinks);
> }
> 
> bool WKPageIsPlayingAudio(WKPageRef page)
> {
>-    return toImpl(page)->isPlayingAudio();
>+    return WebKit::toImpl(page)->isPlayingAudio();
> }
> 
> WKMediaState WKPageGetMediaState(WKPageRef page)
> {
>-    WebCore::MediaProducer::MediaStateFlags coreState = toImpl(page)->mediaStateFlags();
>+    WebCore::MediaProducer::MediaStateFlags coreState = WebKit::toImpl(page)->mediaStateFlags();
>     WKMediaState state = kWKMediaIsNotPlaying;
> 
>     if (coreState & WebCore::MediaProducer::IsPlayingAudio)
>@@ -2654,43 +2654,43 @@ WKMediaState WKPageGetMediaState(WKPageRef page)
> 
> void WKPageClearWheelEventTestTrigger(WKPageRef pageRef)
> {
>-    toImpl(pageRef)->clearWheelEventTestTrigger();
>+    WebKit::toImpl(pageRef)->clearWheelEventTestTrigger();
> }
> 
> void WKPageCallAfterNextPresentationUpdate(WKPageRef pageRef, void* context, WKPagePostPresentationUpdateFunction callback)
> {
>-    toImpl(pageRef)->callAfterNextPresentationUpdate([context, callback](WebKit::CallbackBase::Error error) {
>+    WebKit::toImpl(pageRef)->callAfterNextPresentationUpdate([context, callback](WebKit::CallbackBase::Error error) {
>         callback(error != WebKit::CallbackBase::Error::None ? toAPI(API::Error::create().ptr()) : 0, context);
>     });
> }
> 
> bool WKPageGetResourceCachingDisabled(WKPageRef page)
> {
>-    return toImpl(page)->isResourceCachingDisabled();
>+    return WebKit::toImpl(page)->isResourceCachingDisabled();
> }
> 
> void WKPageSetResourceCachingDisabled(WKPageRef page, bool disabled)
> {
>-    toImpl(page)->setResourceCachingDisabled(disabled);
>+    WebKit::toImpl(page)->setResourceCachingDisabled(disabled);
> }
> 
> void WKPageSetIgnoresViewportScaleLimits(WKPageRef page, bool ignoresViewportScaleLimits)
> {
> #if PLATFORM(IOS_FAMILY)
>-    toImpl(page)->setForceAlwaysUserScalable(ignoresViewportScaleLimits);
>+    WebKit::toImpl(page)->setForceAlwaysUserScalable(ignoresViewportScaleLimits);
> #endif
> }
> 
> ProcessID WKPageGetProcessIdentifier(WKPageRef page)
> {
>-    return toImpl(page)->processIdentifier();
>+    return WebKit::toImpl(page)->processIdentifier();
> }
> 
> #ifdef __BLOCKS__
> void WKPageGetApplicationManifest_b(WKPageRef page, WKPageGetApplicationManifestBlock block)
> {
> #if ENABLE(APPLICATION_MANIFEST)
>-    toImpl(page)->getApplicationManifest([block](const std::optional<WebCore::ApplicationManifest> &manifest, CallbackBase::Error) {
>+    WebKit::toImpl(page)->getApplicationManifest([block](const std::optional<WebCore::ApplicationManifest> &manifest, CallbackBase::Error) {
>         block();
>     });
> #else // ENABLE(APPLICATION_MANIFEST)
>diff --git a/Source/WebKit/UIProcess/API/C/WKPageConfigurationRef.cpp b/Source/WebKit/UIProcess/API/C/WKPageConfigurationRef.cpp
>index c754a9f56f6bcfa067b20cae7e098ac0e225117c..64dadcb209ad00c02c0e7c4046272c482f5d0107 100644
>--- a/Source/WebKit/UIProcess/API/C/WKPageConfigurationRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKPageConfigurationRef.cpp
>@@ -46,70 +46,70 @@ WKPageConfigurationRef WKPageConfigurationCreate()
> 
> WKContextRef WKPageConfigurationGetContext(WKPageConfigurationRef configuration)
> {
>-    return toAPI(toImpl(configuration)->processPool());
>+    return toAPI(WebKit::toImpl(configuration)->processPool());
> }
> 
> void WKPageConfigurationSetContext(WKPageConfigurationRef configuration, WKContextRef context)
> {
>-    toImpl(configuration)->setProcessPool(toImpl(context));
>+    WebKit::toImpl(configuration)->setProcessPool(WebKit::toImpl(context));
> }
> 
> WKPageGroupRef WKPageConfigurationGetPageGroup(WKPageConfigurationRef configuration)
> {
>-    return toAPI(toImpl(configuration)->pageGroup());
>+    return toAPI(WebKit::toImpl(configuration)->pageGroup());
> }
> 
> void WKPageConfigurationSetPageGroup(WKPageConfigurationRef configuration, WKPageGroupRef pageGroup)
> {
>-    toImpl(configuration)->setPageGroup(toImpl(pageGroup));
>+    WebKit::toImpl(configuration)->setPageGroup(WebKit::toImpl(pageGroup));
> }
> 
> WKUserContentControllerRef WKPageConfigurationGetUserContentController(WKPageConfigurationRef configuration)
> {
>-    return toAPI(toImpl(configuration)->userContentController());
>+    return toAPI(WebKit::toImpl(configuration)->userContentController());
> }
> 
> void WKPageConfigurationSetUserContentController(WKPageConfigurationRef configuration, WKUserContentControllerRef userContentController)
> {
>-    toImpl(configuration)->setUserContentController(toImpl(userContentController));
>+    WebKit::toImpl(configuration)->setUserContentController(WebKit::toImpl(userContentController));
> }
> 
> WKPreferencesRef WKPageConfigurationGetPreferences(WKPageConfigurationRef configuration)
> {
>-    return toAPI(toImpl(configuration)->preferences());
>+    return toAPI(WebKit::toImpl(configuration)->preferences());
> }
> 
> void WKPageConfigurationSetPreferences(WKPageConfigurationRef configuration, WKPreferencesRef preferences)
> {
>-    toImpl(configuration)->setPreferences(toImpl(preferences));
>+    WebKit::toImpl(configuration)->setPreferences(WebKit::toImpl(preferences));
> }
> 
> WKPageRef WKPageConfigurationGetRelatedPage(WKPageConfigurationRef configuration)
> {
>-    return toAPI(toImpl(configuration)->relatedPage());
>+    return toAPI(WebKit::toImpl(configuration)->relatedPage());
> }
> 
> void WKPageConfigurationSetRelatedPage(WKPageConfigurationRef configuration, WKPageRef relatedPage)
> {
>-    toImpl(configuration)->setRelatedPage(toImpl(relatedPage));
>+    WebKit::toImpl(configuration)->setRelatedPage(WebKit::toImpl(relatedPage));
> }
> 
> WKWebsiteDataStoreRef WKPageConfigurationGetWebsiteDataStore(WKPageConfigurationRef configuration)
> {
>-    return toAPI(toImpl(configuration)->websiteDataStore());
>+    return toAPI(WebKit::toImpl(configuration)->websiteDataStore());
> }
> 
> void WKPageConfigurationSetWebsiteDataStore(WKPageConfigurationRef configuration, WKWebsiteDataStoreRef websiteDataStore)
> {
>-    toImpl(configuration)->setWebsiteDataStore(toImpl(websiteDataStore));
>+    WebKit::toImpl(configuration)->setWebsiteDataStore(WebKit::toImpl(websiteDataStore));
> }
> 
> void WKPageConfigurationSetInitialCapitalizationEnabled(WKPageConfigurationRef configuration, bool enabled)
> {
>-    toImpl(configuration)->setInitialCapitalizationEnabled(enabled);
>+    WebKit::toImpl(configuration)->setInitialCapitalizationEnabled(enabled);
> }
> 
> void WKPageConfigurationSetBackgroundCPULimit(WKPageConfigurationRef configuration, double cpuLimit)
> {
>-    toImpl(configuration)->setCPULimit(cpuLimit);
>+    WebKit::toImpl(configuration)->setCPULimit(cpuLimit);
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKPageGroup.cpp b/Source/WebKit/UIProcess/API/C/WKPageGroup.cpp
>index 0377410ea7e67e6b0910cfbc05a9b32f58cb43e2..f6efc4d124b308815901429476e5025c99187dc8 100644
>--- a/Source/WebKit/UIProcess/API/C/WKPageGroup.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKPageGroup.cpp
>@@ -53,17 +53,17 @@ WKPageGroupRef WKPageGroupCreateWithIdentifier(WKStringRef identifier)
> 
> void WKPageGroupSetPreferences(WKPageGroupRef pageGroupRef, WKPreferencesRef preferencesRef)
> {
>-    toImpl(pageGroupRef)->setPreferences(toImpl(preferencesRef));
>+    WebKit::toImpl(pageGroupRef)->setPreferences(WebKit::toImpl(preferencesRef));
> }
> 
> WKPreferencesRef WKPageGroupGetPreferences(WKPageGroupRef pageGroupRef)
> {
>-    return toAPI(&toImpl(pageGroupRef)->preferences());
>+    return toAPI(&WebKit::toImpl(pageGroupRef)->preferences());
> }
> 
> WKUserContentControllerRef WKPageGroupGetUserContentController(WKPageGroupRef pageGroupRef)
> {
>-    return toAPI(&toImpl(pageGroupRef)->userContentController());
>+    return toAPI(&WebKit::toImpl(pageGroupRef)->userContentController());
> }
> 
> void WKPageGroupAddUserStyleSheet(WKPageGroupRef pageGroupRef, WKStringRef sourceRef, WKURLRef baseURLRef, WKArrayRef whitelistedURLPatterns, WKArrayRef blacklistedURLPatterns, WKUserContentInjectedFrames injectedFrames)
>@@ -74,17 +74,17 @@ void WKPageGroupAddUserStyleSheet(WKPageGroupRef pageGroupRef, WKStringRef sourc
>         return;
> 
>     auto baseURLString = toWTFString(baseURLRef);
>-    auto whitelist = toImpl(whitelistedURLPatterns);
>-    auto blacklist = toImpl(blacklistedURLPatterns);
>+    auto whitelist = WebKit::toImpl(whitelistedURLPatterns);
>+    auto blacklist = WebKit::toImpl(blacklistedURLPatterns);
> 
>     Ref<API::UserStyleSheet> userStyleSheet = API::UserStyleSheet::create(WebCore::UserStyleSheet { source, (baseURLString.isEmpty() ? WTF::blankURL() :  URL(URL(), baseURLString)), whitelist ? whitelist->toStringVector() : Vector<String>(), blacklist ? blacklist->toStringVector() : Vector<String>(), toUserContentInjectedFrames(injectedFrames), WebCore::UserStyleUserLevel }, API::UserContentWorld::normalWorld());
> 
>-    toImpl(pageGroupRef)->userContentController().addUserStyleSheet(userStyleSheet.get());
>+    WebKit::toImpl(pageGroupRef)->userContentController().addUserStyleSheet(userStyleSheet.get());
> }
> 
> void WKPageGroupRemoveAllUserStyleSheets(WKPageGroupRef pageGroup)
> {
>-    toImpl(pageGroup)->userContentController().removeAllUserStyleSheets();
>+    WebKit::toImpl(pageGroup)->userContentController().removeAllUserStyleSheets();
> }
> 
> void WKPageGroupAddUserScript(WKPageGroupRef pageGroupRef, WKStringRef sourceRef, WKURLRef baseURLRef, WKArrayRef whitelistedURLPatterns, WKArrayRef blacklistedURLPatterns, WKUserContentInjectedFrames injectedFrames, _WKUserScriptInjectionTime injectionTime)
>@@ -95,15 +95,15 @@ void WKPageGroupAddUserScript(WKPageGroupRef pageGroupRef, WKStringRef sourceRef
>         return;
> 
>     auto baseURLString = toWTFString(baseURLRef);
>-    auto whitelist = toImpl(whitelistedURLPatterns);
>-    auto blacklist = toImpl(blacklistedURLPatterns);
>+    auto whitelist = WebKit::toImpl(whitelistedURLPatterns);
>+    auto blacklist = WebKit::toImpl(blacklistedURLPatterns);
>     
>     auto url = baseURLString.isEmpty() ? WTF::blankURL() :  URL(URL(), baseURLString);
>     Ref<API::UserScript> userScript = API::UserScript::create(WebCore::UserScript { WTFMove(source), WTFMove(url), whitelist ? whitelist->toStringVector() : Vector<String>(), blacklist ? blacklist->toStringVector() : Vector<String>(), toUserScriptInjectionTime(injectionTime), toUserContentInjectedFrames(injectedFrames) }, API::UserContentWorld::normalWorld());
>-    toImpl(pageGroupRef)->userContentController().addUserScript(userScript.get(), InjectUserScriptImmediately::No);
>+    WebKit::toImpl(pageGroupRef)->userContentController().addUserScript(userScript.get(), InjectUserScriptImmediately::No);
> }
> 
> void WKPageGroupRemoveAllUserScripts(WKPageGroupRef pageGroupRef)
> {
>-    toImpl(pageGroupRef)->userContentController().removeAllUserScripts();
>+    WebKit::toImpl(pageGroupRef)->userContentController().removeAllUserScripts();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKPreferences.cpp b/Source/WebKit/UIProcess/API/C/WKPreferences.cpp
>index 9bc94b477548b1f961b5f019f298416bd42a9450..1dba6167631c94d6c23cd0858ce826c6a6cd1050 100644
>--- a/Source/WebKit/UIProcess/API/C/WKPreferences.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKPreferences.cpp
>@@ -54,709 +54,709 @@ WKPreferencesRef WKPreferencesCreateWithIdentifier(WKStringRef identifierRef)
> 
> WKPreferencesRef WKPreferencesCreateCopy(WKPreferencesRef preferencesRef)
> {
>-    auto preferences = toImpl(preferencesRef)->copy();
>+    auto preferences = WebKit::toImpl(preferencesRef)->copy();
>     return toAPI(&preferences.leakRef());
> }
> 
> void WKPreferencesEnableAllExperimentalFeatures(WKPreferencesRef preferencesRef)
> {
>-    toImpl(preferencesRef)->enableAllExperimentalFeatures();
>+    WebKit::toImpl(preferencesRef)->enableAllExperimentalFeatures();
> }
> 
> void WKPreferencesSetExperimentalFeatureForKey(WKPreferencesRef preferencesRef, bool value, WKStringRef experimentalFeatureKey)
> {
>-    toImpl(preferencesRef)->setExperimentalFeatureEnabledForKey(toWTFString(experimentalFeatureKey), value);
>+    WebKit::toImpl(preferencesRef)->setExperimentalFeatureEnabledForKey(toWTFString(experimentalFeatureKey), value);
> }
> 
> void WKPreferencesResetAllInternalDebugFeatures(WKPreferencesRef preferencesRef)
> {
>-    toImpl(preferencesRef)->resetAllInternalDebugFeatures();
>+    WebKit::toImpl(preferencesRef)->resetAllInternalDebugFeatures();
> }
> 
> void WKPreferencesSetInternalDebugFeatureForKey(WKPreferencesRef preferencesRef, bool value, WKStringRef internalDebugFeatureKey)
> {
>-    toImpl(preferencesRef)->setInternalDebugFeatureEnabledForKey(toWTFString(internalDebugFeatureKey), value);
>+    WebKit::toImpl(preferencesRef)->setInternalDebugFeatureEnabledForKey(toWTFString(internalDebugFeatureKey), value);
> }
> 
> void WKPreferencesSetJavaScriptEnabled(WKPreferencesRef preferencesRef, bool javaScriptEnabled)
> {
>-    toImpl(preferencesRef)->setJavaScriptEnabled(javaScriptEnabled);
>+    WebKit::toImpl(preferencesRef)->setJavaScriptEnabled(javaScriptEnabled);
> }
> 
> bool WKPreferencesGetJavaScriptEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaScriptEnabled();
>+    return WebKit::toImpl(preferencesRef)->javaScriptEnabled();
> }
> 
> void WKPreferencesSetJavaScriptMarkupEnabled(WKPreferencesRef preferencesRef, bool javaScriptMarkupEnabled)
> {
>-    toImpl(preferencesRef)->setJavaScriptMarkupEnabled(javaScriptMarkupEnabled);
>+    WebKit::toImpl(preferencesRef)->setJavaScriptMarkupEnabled(javaScriptMarkupEnabled);
> }
> 
> bool WKPreferencesGetJavaScriptMarkupEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaScriptMarkupEnabled();
>+    return WebKit::toImpl(preferencesRef)->javaScriptMarkupEnabled();
> }
> 
> void WKPreferencesSetLoadsImagesAutomatically(WKPreferencesRef preferencesRef, bool loadsImagesAutomatically)
> {
>-    toImpl(preferencesRef)->setLoadsImagesAutomatically(loadsImagesAutomatically);
>+    WebKit::toImpl(preferencesRef)->setLoadsImagesAutomatically(loadsImagesAutomatically);
> }
> 
> bool WKPreferencesGetLoadsImagesAutomatically(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->loadsImagesAutomatically();
>+    return WebKit::toImpl(preferencesRef)->loadsImagesAutomatically();
> }
> 
> void WKPreferencesSetLoadsSiteIconsIgnoringImageLoadingPreference(WKPreferencesRef preferencesRef, bool loadsSiteIconsIgnoringImageLoadingPreference)
> {
>-    toImpl(preferencesRef)->setLoadsSiteIconsIgnoringImageLoadingPreference(loadsSiteIconsIgnoringImageLoadingPreference);
>+    WebKit::toImpl(preferencesRef)->setLoadsSiteIconsIgnoringImageLoadingPreference(loadsSiteIconsIgnoringImageLoadingPreference);
> }
> 
> bool WKPreferencesGetLoadsSiteIconsIgnoringImageLoadingPreference(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->loadsSiteIconsIgnoringImageLoadingPreference();
>+    return WebKit::toImpl(preferencesRef)->loadsSiteIconsIgnoringImageLoadingPreference();
> }
> 
> void WKPreferencesSetOfflineWebApplicationCacheEnabled(WKPreferencesRef preferencesRef, bool offlineWebApplicationCacheEnabled)
> {
>-    toImpl(preferencesRef)->setOfflineWebApplicationCacheEnabled(offlineWebApplicationCacheEnabled);
>+    WebKit::toImpl(preferencesRef)->setOfflineWebApplicationCacheEnabled(offlineWebApplicationCacheEnabled);
> }
> 
> bool WKPreferencesGetOfflineWebApplicationCacheEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->offlineWebApplicationCacheEnabled();
>+    return WebKit::toImpl(preferencesRef)->offlineWebApplicationCacheEnabled();
> }
> 
> void WKPreferencesSetLocalStorageEnabled(WKPreferencesRef preferencesRef, bool localStorageEnabled)
> {
>-    toImpl(preferencesRef)->setLocalStorageEnabled(localStorageEnabled);
>+    WebKit::toImpl(preferencesRef)->setLocalStorageEnabled(localStorageEnabled);
> }
> 
> bool WKPreferencesGetLocalStorageEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->localStorageEnabled();
>+    return WebKit::toImpl(preferencesRef)->localStorageEnabled();
> }
> 
> void WKPreferencesSetDatabasesEnabled(WKPreferencesRef preferencesRef, bool databasesEnabled)
> {
>-    toImpl(preferencesRef)->setDatabasesEnabled(databasesEnabled);
>+    WebKit::toImpl(preferencesRef)->setDatabasesEnabled(databasesEnabled);
> }
> 
> bool WKPreferencesGetDatabasesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->databasesEnabled();
>+    return WebKit::toImpl(preferencesRef)->databasesEnabled();
> }
> 
> void WKPreferencesSetXSSAuditorEnabled(WKPreferencesRef preferencesRef, bool xssAuditorEnabled)
> {
>-    toImpl(preferencesRef)->setXSSAuditorEnabled(xssAuditorEnabled);
>+    WebKit::toImpl(preferencesRef)->setXSSAuditorEnabled(xssAuditorEnabled);
> }
> 
> bool WKPreferencesGetXSSAuditorEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->xssAuditorEnabled();
>+    return WebKit::toImpl(preferencesRef)->xssAuditorEnabled();
> }
> 
> void WKPreferencesSetFrameFlatteningEnabled(WKPreferencesRef preferencesRef, bool frameFlatteningEnabled)
> {
>-    toImpl(preferencesRef)->setFrameFlatteningEnabled(frameFlatteningEnabled);
>+    WebKit::toImpl(preferencesRef)->setFrameFlatteningEnabled(frameFlatteningEnabled);
> }
> 
> bool WKPreferencesGetFrameFlatteningEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->frameFlatteningEnabled();
>+    return WebKit::toImpl(preferencesRef)->frameFlatteningEnabled();
> }
> 
> void WKPreferencesSetPluginsEnabled(WKPreferencesRef preferencesRef, bool pluginsEnabled)
> {
>-    toImpl(preferencesRef)->setPluginsEnabled(pluginsEnabled);
>+    WebKit::toImpl(preferencesRef)->setPluginsEnabled(pluginsEnabled);
> }
> 
> bool WKPreferencesGetPluginsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->pluginsEnabled();
>+    return WebKit::toImpl(preferencesRef)->pluginsEnabled();
> }
> 
> void WKPreferencesSetJavaEnabled(WKPreferencesRef preferencesRef, bool javaEnabled)
> {
>-    toImpl(preferencesRef)->setJavaEnabled(javaEnabled);
>+    WebKit::toImpl(preferencesRef)->setJavaEnabled(javaEnabled);
> }
> 
> bool WKPreferencesGetJavaEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaEnabled();
>+    return WebKit::toImpl(preferencesRef)->javaEnabled();
> }
> 
> void WKPreferencesSetJavaEnabledForLocalFiles(WKPreferencesRef preferencesRef, bool javaEnabledForLocalFiles)
> {
>-    toImpl(preferencesRef)->setJavaEnabledForLocalFiles(javaEnabledForLocalFiles);
>+    WebKit::toImpl(preferencesRef)->setJavaEnabledForLocalFiles(javaEnabledForLocalFiles);
> }
> 
> bool WKPreferencesGetJavaEnabledForLocalFiles(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaEnabledForLocalFiles();
>+    return WebKit::toImpl(preferencesRef)->javaEnabledForLocalFiles();
> }
> 
> void WKPreferencesSetJavaScriptCanOpenWindowsAutomatically(WKPreferencesRef preferencesRef, bool javaScriptCanOpenWindowsAutomatically)
> {
>-    toImpl(preferencesRef)->setJavaScriptCanOpenWindowsAutomatically(javaScriptCanOpenWindowsAutomatically);
>+    WebKit::toImpl(preferencesRef)->setJavaScriptCanOpenWindowsAutomatically(javaScriptCanOpenWindowsAutomatically);
> }
> 
> bool WKPreferencesGetJavaScriptCanOpenWindowsAutomatically(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaScriptCanOpenWindowsAutomatically();
>+    return WebKit::toImpl(preferencesRef)->javaScriptCanOpenWindowsAutomatically();
> }
> 
> void WKPreferencesSetStorageAccessPromptsEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setStorageAccessPromptsEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setStorageAccessPromptsEnabled(enabled);
> }
> 
> bool WKPreferencesGetStorageAccessPromptsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->storageAccessPromptsEnabled();
>+    return WebKit::toImpl(preferencesRef)->storageAccessPromptsEnabled();
> }
> 
> void WKPreferencesSetHyperlinkAuditingEnabled(WKPreferencesRef preferencesRef, bool hyperlinkAuditingEnabled)
> {
>-    toImpl(preferencesRef)->setHyperlinkAuditingEnabled(hyperlinkAuditingEnabled);
>+    WebKit::toImpl(preferencesRef)->setHyperlinkAuditingEnabled(hyperlinkAuditingEnabled);
> }
> 
> bool WKPreferencesGetHyperlinkAuditingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->hyperlinkAuditingEnabled();
>+    return WebKit::toImpl(preferencesRef)->hyperlinkAuditingEnabled();
> }
> 
> void WKPreferencesSetStandardFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setStandardFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setStandardFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopyStandardFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->standardFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->standardFontFamily());
> }
> 
> void WKPreferencesSetFixedFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setFixedFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setFixedFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopyFixedFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->fixedFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->fixedFontFamily());
> }
> 
> void WKPreferencesSetSerifFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setSerifFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setSerifFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopySerifFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->serifFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->serifFontFamily());
> }
> 
> void WKPreferencesSetSansSerifFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setSansSerifFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setSansSerifFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopySansSerifFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->sansSerifFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->sansSerifFontFamily());
> }
> 
> void WKPreferencesSetCursiveFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setCursiveFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setCursiveFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopyCursiveFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->cursiveFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->cursiveFontFamily());
> }
> 
> void WKPreferencesSetFantasyFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setFantasyFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setFantasyFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopyFantasyFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->fantasyFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->fantasyFontFamily());
> }
> 
> void WKPreferencesSetPictographFontFamily(WKPreferencesRef preferencesRef, WKStringRef family)
> {
>-    toImpl(preferencesRef)->setPictographFontFamily(toWTFString(family));
>+    WebKit::toImpl(preferencesRef)->setPictographFontFamily(toWTFString(family));
> }
> 
> WKStringRef WKPreferencesCopyPictographFontFamily(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->pictographFontFamily());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->pictographFontFamily());
> }
> 
> void WKPreferencesSetDefaultFontSize(WKPreferencesRef preferencesRef, uint32_t size)
> {
>-    toImpl(preferencesRef)->setDefaultFontSize(size);
>+    WebKit::toImpl(preferencesRef)->setDefaultFontSize(size);
> }
> 
> uint32_t WKPreferencesGetDefaultFontSize(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->defaultFontSize();
>+    return WebKit::toImpl(preferencesRef)->defaultFontSize();
> }
> 
> void WKPreferencesSetDefaultFixedFontSize(WKPreferencesRef preferencesRef, uint32_t size)
> {
>-    toImpl(preferencesRef)->setDefaultFixedFontSize(size);
>+    WebKit::toImpl(preferencesRef)->setDefaultFixedFontSize(size);
> }
> 
> uint32_t WKPreferencesGetDefaultFixedFontSize(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->defaultFixedFontSize();
>+    return WebKit::toImpl(preferencesRef)->defaultFixedFontSize();
> }
> 
> void WKPreferencesSetMinimumFontSize(WKPreferencesRef preferencesRef, uint32_t size)
> {
>-    toImpl(preferencesRef)->setMinimumFontSize(size);
>+    WebKit::toImpl(preferencesRef)->setMinimumFontSize(size);
> }
> 
> uint32_t WKPreferencesGetMinimumFontSize(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->minimumFontSize();
>+    return WebKit::toImpl(preferencesRef)->minimumFontSize();
> }
> 
> 
> void WKPreferencesSetCookieEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setCookieEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setCookieEnabled(enabled);
> }
> 
> bool WKPreferencesGetCookieEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->cookieEnabled();
>+    return WebKit::toImpl(preferencesRef)->cookieEnabled();
> }
> 
> void WKPreferencesSetEditableLinkBehavior(WKPreferencesRef preferencesRef, WKEditableLinkBehavior wkBehavior)
> {
>-    toImpl(preferencesRef)->setEditableLinkBehavior(toEditableLinkBehavior(wkBehavior));
>+    WebKit::toImpl(preferencesRef)->setEditableLinkBehavior(toEditableLinkBehavior(wkBehavior));
> }
> 
> WKEditableLinkBehavior WKPreferencesGetEditableLinkBehavior(WKPreferencesRef preferencesRef)
> {
>-    return toAPI(static_cast<WebCore::EditableLinkBehavior>(toImpl(preferencesRef)->editableLinkBehavior()));
>+    return toAPI(static_cast<WebCore::EditableLinkBehavior>(WebKit::toImpl(preferencesRef)->editableLinkBehavior()));
> }
> 
> void WKPreferencesSetDefaultTextEncodingName(WKPreferencesRef preferencesRef, WKStringRef name)
> {
>-    toImpl(preferencesRef)->setDefaultTextEncodingName(toWTFString(name));
>+    WebKit::toImpl(preferencesRef)->setDefaultTextEncodingName(toWTFString(name));
> }
> 
> WKStringRef WKPreferencesCopyDefaultTextEncodingName(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->defaultTextEncodingName());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->defaultTextEncodingName());
> }
> 
> void WKPreferencesSetPrivateBrowsingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPrivateBrowsingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPrivateBrowsingEnabled(enabled);
> }
> 
> bool WKPreferencesGetPrivateBrowsingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->privateBrowsingEnabled();
>+    return WebKit::toImpl(preferencesRef)->privateBrowsingEnabled();
> }
> 
> void WKPreferencesSetDeveloperExtrasEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setDeveloperExtrasEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setDeveloperExtrasEnabled(enabled);
> }
> 
> bool WKPreferencesGetDeveloperExtrasEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->developerExtrasEnabled();
>+    return WebKit::toImpl(preferencesRef)->developerExtrasEnabled();
> }
> 
> void WKPreferencesSetJavaScriptRuntimeFlags(WKPreferencesRef preferencesRef, WKJavaScriptRuntimeFlagSet javaScriptRuntimeFlagSet)
> {
>-    toImpl(preferencesRef)->setJavaScriptRuntimeFlags(javaScriptRuntimeFlagSet);
>+    WebKit::toImpl(preferencesRef)->setJavaScriptRuntimeFlags(javaScriptRuntimeFlagSet);
> }
> 
> WKJavaScriptRuntimeFlagSet WKPreferencesGetJavaScriptRuntimeFlags(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaScriptRuntimeFlags();
>+    return WebKit::toImpl(preferencesRef)->javaScriptRuntimeFlags();
> }
> 
> void WKPreferencesSetTextAreasAreResizable(WKPreferencesRef preferencesRef, bool resizable)
> {
>-    toImpl(preferencesRef)->setTextAreasAreResizable(resizable);
>+    WebKit::toImpl(preferencesRef)->setTextAreasAreResizable(resizable);
> }
> 
> bool WKPreferencesGetTextAreasAreResizable(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->textAreasAreResizable();
>+    return WebKit::toImpl(preferencesRef)->textAreasAreResizable();
> }
> 
> void WKPreferencesSetSubpixelAntialiasedLayerTextEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setSubpixelAntialiasedLayerTextEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setSubpixelAntialiasedLayerTextEnabled(flag);
> }
> 
> bool WKPreferencesGetSubpixelAntialiasedLayerTextEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->subpixelAntialiasedLayerTextEnabled();
>+    return WebKit::toImpl(preferencesRef)->subpixelAntialiasedLayerTextEnabled();
> }
> 
> void WKPreferencesSetAcceleratedDrawingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAcceleratedDrawingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAcceleratedDrawingEnabled(flag);
> }
> 
> bool WKPreferencesGetAcceleratedDrawingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->acceleratedDrawingEnabled();
>+    return WebKit::toImpl(preferencesRef)->acceleratedDrawingEnabled();
> }
> 
> void WKPreferencesSetCanvasUsesAcceleratedDrawing(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCanvasUsesAcceleratedDrawing(flag);
>+    WebKit::toImpl(preferencesRef)->setCanvasUsesAcceleratedDrawing(flag);
> }
> 
> bool WKPreferencesGetCanvasUsesAcceleratedDrawing(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->canvasUsesAcceleratedDrawing();
>+    return WebKit::toImpl(preferencesRef)->canvasUsesAcceleratedDrawing();
> }
> 
> void WKPreferencesSetAcceleratedCompositingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAcceleratedCompositingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAcceleratedCompositingEnabled(flag);
> }
> 
> bool WKPreferencesGetAcceleratedCompositingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->acceleratedCompositingEnabled();
>+    return WebKit::toImpl(preferencesRef)->acceleratedCompositingEnabled();
> }
> 
> void WKPreferencesSetCompositingBordersVisible(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCompositingBordersVisible(flag);
>+    WebKit::toImpl(preferencesRef)->setCompositingBordersVisible(flag);
> }
> 
> bool WKPreferencesGetCompositingBordersVisible(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->compositingBordersVisible();
>+    return WebKit::toImpl(preferencesRef)->compositingBordersVisible();
> }
> 
> void WKPreferencesSetCompositingRepaintCountersVisible(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCompositingRepaintCountersVisible(flag);
>+    WebKit::toImpl(preferencesRef)->setCompositingRepaintCountersVisible(flag);
> }
> 
> bool WKPreferencesGetCompositingRepaintCountersVisible(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->compositingRepaintCountersVisible();
>+    return WebKit::toImpl(preferencesRef)->compositingRepaintCountersVisible();
> }
> 
> void WKPreferencesSetTiledScrollingIndicatorVisible(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setTiledScrollingIndicatorVisible(flag);
>+    WebKit::toImpl(preferencesRef)->setTiledScrollingIndicatorVisible(flag);
> }
> 
> bool WKPreferencesGetTiledScrollingIndicatorVisible(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->tiledScrollingIndicatorVisible();
>+    return WebKit::toImpl(preferencesRef)->tiledScrollingIndicatorVisible();
> }
> 
> void WKPreferencesSetWebGLEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setWebGLEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setWebGLEnabled(flag);
> }
> 
> bool WKPreferencesGetWebGLEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webGLEnabled();
>+    return WebKit::toImpl(preferencesRef)->webGLEnabled();
> }
> 
> void WKPreferencesSetForceSoftwareWebGLRendering(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setForceSoftwareWebGLRendering(flag);
>+    WebKit::toImpl(preferencesRef)->setForceSoftwareWebGLRendering(flag);
> }
> 
> bool WKPreferencesGetForceSoftwareWebGLRendering(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->forceSoftwareWebGLRendering();
>+    return WebKit::toImpl(preferencesRef)->forceSoftwareWebGLRendering();
> }
> 
> void WKPreferencesSetAccelerated2DCanvasEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAccelerated2dCanvasEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAccelerated2dCanvasEnabled(flag);
> }
> 
> bool WKPreferencesGetAccelerated2DCanvasEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->accelerated2dCanvasEnabled();
>+    return WebKit::toImpl(preferencesRef)->accelerated2dCanvasEnabled();
> }
> 
> void WKPreferencesSetWebAnimationsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setWebAnimationsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setWebAnimationsEnabled(flag);
> }
> 
> bool WKPreferencesGetWebAnimationsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webAnimationsEnabled();
>+    return WebKit::toImpl(preferencesRef)->webAnimationsEnabled();
> }
> 
> void WKPreferencesSetWebAnimationsCSSIntegrationEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setWebAnimationsCSSIntegrationEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setWebAnimationsCSSIntegrationEnabled(flag);
> }
> 
> bool WKPreferencesGetWebAnimationsCSSIntegrationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webAnimationsCSSIntegrationEnabled();
>+    return WebKit::toImpl(preferencesRef)->webAnimationsCSSIntegrationEnabled();
> }
> 
> void WKPreferencesSetNeedsSiteSpecificQuirks(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setNeedsSiteSpecificQuirks(flag);
>+    WebKit::toImpl(preferencesRef)->setNeedsSiteSpecificQuirks(flag);
> }
> 
> bool WKPreferencesUseLegacyTextAlignPositionedElementBehavior(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->useLegacyTextAlignPositionedElementBehavior();
>+    return WebKit::toImpl(preferencesRef)->useLegacyTextAlignPositionedElementBehavior();
> }
> 
> void WKPreferencesSetUseLegacyTextAlignPositionedElementBehavior(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setUseLegacyTextAlignPositionedElementBehavior(flag);
>+    WebKit::toImpl(preferencesRef)->setUseLegacyTextAlignPositionedElementBehavior(flag);
> }
> 
> bool WKPreferencesGetNeedsSiteSpecificQuirks(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->needsSiteSpecificQuirks();
>+    return WebKit::toImpl(preferencesRef)->needsSiteSpecificQuirks();
> }
> 
> void WKPreferencesSetForceFTPDirectoryListings(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setForceFTPDirectoryListings(flag);
>+    WebKit::toImpl(preferencesRef)->setForceFTPDirectoryListings(flag);
> }
> 
> bool WKPreferencesGetForceFTPDirectoryListings(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->forceFTPDirectoryListings();
>+    return WebKit::toImpl(preferencesRef)->forceFTPDirectoryListings();
> }
> 
> void WKPreferencesSetFTPDirectoryTemplatePath(WKPreferencesRef preferencesRef, WKStringRef pathRef)
> {
>-    toImpl(preferencesRef)->setFTPDirectoryTemplatePath(toWTFString(pathRef));
>+    WebKit::toImpl(preferencesRef)->setFTPDirectoryTemplatePath(toWTFString(pathRef));
> }
> 
> WKStringRef WKPreferencesCopyFTPDirectoryTemplatePath(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->ftpDirectoryTemplatePath());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->ftpDirectoryTemplatePath());
> }
> 
> void WKPreferencesSetTabsToLinks(WKPreferencesRef preferencesRef, bool tabsToLinks)
> {
>-    toImpl(preferencesRef)->setTabsToLinks(tabsToLinks);
>+    WebKit::toImpl(preferencesRef)->setTabsToLinks(tabsToLinks);
> }
> 
> bool WKPreferencesGetTabsToLinks(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->tabsToLinks();
>+    return WebKit::toImpl(preferencesRef)->tabsToLinks();
> }
> 
> void WKPreferencesSetDNSPrefetchingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setDNSPrefetchingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setDNSPrefetchingEnabled(enabled);
> }
> 
> bool WKPreferencesGetDNSPrefetchingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->dnsPrefetchingEnabled();
>+    return WebKit::toImpl(preferencesRef)->dnsPrefetchingEnabled();
> }
> 
> void WKPreferencesSetAuthorAndUserStylesEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAuthorAndUserStylesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAuthorAndUserStylesEnabled(enabled);
> }
> 
> bool WKPreferencesGetAuthorAndUserStylesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->authorAndUserStylesEnabled();
>+    return WebKit::toImpl(preferencesRef)->authorAndUserStylesEnabled();
> }
> 
> void WKPreferencesSetShouldPrintBackgrounds(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setShouldPrintBackgrounds(flag);
>+    WebKit::toImpl(preferencesRef)->setShouldPrintBackgrounds(flag);
> }
> 
> bool WKPreferencesGetShouldPrintBackgrounds(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldPrintBackgrounds();
>+    return WebKit::toImpl(preferencesRef)->shouldPrintBackgrounds();
> }
> 
> void WKPreferencesSetDOMTimersThrottlingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setDOMTimersThrottlingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setDOMTimersThrottlingEnabled(enabled);
> }
> 
> bool WKPreferencesGetDOMTimersThrottlingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->domTimersThrottlingEnabled();
>+    return WebKit::toImpl(preferencesRef)->domTimersThrottlingEnabled();
> }
> 
> void WKPreferencesSetWebArchiveDebugModeEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setWebArchiveDebugModeEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setWebArchiveDebugModeEnabled(enabled);
> }
> 
> bool WKPreferencesGetWebArchiveDebugModeEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webArchiveDebugModeEnabled();
>+    return WebKit::toImpl(preferencesRef)->webArchiveDebugModeEnabled();
> }
> 
> void WKPreferencesSetLocalFileContentSniffingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setLocalFileContentSniffingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setLocalFileContentSniffingEnabled(enabled);
> }
> 
> bool WKPreferencesGetLocalFileContentSniffingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->localFileContentSniffingEnabled();
>+    return WebKit::toImpl(preferencesRef)->localFileContentSniffingEnabled();
> }
> 
> void WKPreferencesSetPageCacheEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setUsesPageCache(enabled);
>+    WebKit::toImpl(preferencesRef)->setUsesPageCache(enabled);
> }
> 
> bool WKPreferencesGetPageCacheEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->usesPageCache();
>+    return WebKit::toImpl(preferencesRef)->usesPageCache();
> }
> 
> void WKPreferencesSetPageCacheSupportsPlugins(WKPreferencesRef preferencesRef, bool pageCacheSupportsPlugins)
> {
>-    toImpl(preferencesRef)->setPageCacheSupportsPlugins(pageCacheSupportsPlugins);
>+    WebKit::toImpl(preferencesRef)->setPageCacheSupportsPlugins(pageCacheSupportsPlugins);
> }
> 
> bool WKPreferencesGetPageCacheSupportsPlugins(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->pageCacheSupportsPlugins();
>+    return WebKit::toImpl(preferencesRef)->pageCacheSupportsPlugins();
> }
> 
> void WKPreferencesSetPaginateDuringLayoutEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPaginateDuringLayoutEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPaginateDuringLayoutEnabled(enabled);
> }
> 
> bool WKPreferencesGetPaginateDuringLayoutEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->paginateDuringLayoutEnabled();
>+    return WebKit::toImpl(preferencesRef)->paginateDuringLayoutEnabled();
> }
> 
> void WKPreferencesSetDOMPasteAllowed(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setDOMPasteAllowed(enabled);
>+    WebKit::toImpl(preferencesRef)->setDOMPasteAllowed(enabled);
> }
> 
> bool WKPreferencesGetDOMPasteAllowed(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->domPasteAllowed();
>+    return WebKit::toImpl(preferencesRef)->domPasteAllowed();
> }
> 
> void WKPreferencesSetJavaScriptCanAccessClipboard(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setJavaScriptCanAccessClipboard(enabled);
>+    WebKit::toImpl(preferencesRef)->setJavaScriptCanAccessClipboard(enabled);
> }
> 
> bool WKPreferencesGetJavaScriptCanAccessClipboard(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->javaScriptCanAccessClipboard();
>+    return WebKit::toImpl(preferencesRef)->javaScriptCanAccessClipboard();
> }
> 
> void WKPreferencesSetFullScreenEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setFullScreenEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setFullScreenEnabled(enabled);
> }
> 
> bool WKPreferencesGetFullScreenEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->fullScreenEnabled();
>+    return WebKit::toImpl(preferencesRef)->fullScreenEnabled();
> }
> 
> void WKPreferencesSetAsynchronousSpellCheckingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAsynchronousSpellCheckingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAsynchronousSpellCheckingEnabled(enabled);
> }
> 
> bool WKPreferencesGetAsynchronousSpellCheckingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->asynchronousSpellCheckingEnabled();
>+    return WebKit::toImpl(preferencesRef)->asynchronousSpellCheckingEnabled();
> }
> 
> void WKPreferencesSetAVFoundationEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAVFoundationEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAVFoundationEnabled(enabled);
> }
> 
> bool WKPreferencesGetAVFoundationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->isAVFoundationEnabled();
>+    return WebKit::toImpl(preferencesRef)->isAVFoundationEnabled();
> }
> 
> void WKPreferencesSetAVFoundationNSURLSessionEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAVFoundationNSURLSessionEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAVFoundationNSURLSessionEnabled(enabled);
> }
> 
> bool WKPreferencesGetAVFoundationNSURLSessionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->isAVFoundationNSURLSessionEnabled();
>+    return WebKit::toImpl(preferencesRef)->isAVFoundationNSURLSessionEnabled();
> }
> 
> void WKPreferencesSetWebSecurityEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setWebSecurityEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setWebSecurityEnabled(enabled);
> }
> 
> bool WKPreferencesGetWebSecurityEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webSecurityEnabled();
>+    return WebKit::toImpl(preferencesRef)->webSecurityEnabled();
> }
> 
> void WKPreferencesSetUniversalAccessFromFileURLsAllowed(WKPreferencesRef preferencesRef, bool allowed)
> {
>-    toImpl(preferencesRef)->setAllowUniversalAccessFromFileURLs(allowed);
>+    WebKit::toImpl(preferencesRef)->setAllowUniversalAccessFromFileURLs(allowed);
> }
> 
> bool WKPreferencesGetUniversalAccessFromFileURLsAllowed(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowUniversalAccessFromFileURLs();
>+    return WebKit::toImpl(preferencesRef)->allowUniversalAccessFromFileURLs();
> }
> 
> void WKPreferencesSetFileAccessFromFileURLsAllowed(WKPreferencesRef preferencesRef, bool allowed)
> {
>-    toImpl(preferencesRef)->setAllowFileAccessFromFileURLs(allowed);
>+    WebKit::toImpl(preferencesRef)->setAllowFileAccessFromFileURLs(allowed);
> }
> 
> bool WKPreferencesGetFileAccessFromFileURLsAllowed(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowFileAccessFromFileURLs();
>+    return WebKit::toImpl(preferencesRef)->allowFileAccessFromFileURLs();
> }
> 
> void WKPreferencesSetNeedsStorageAccessFromFileURLsQuirk(WKPreferencesRef preferencesRef, bool needsQuirk)
> {
>-    toImpl(preferencesRef)->setNeedsStorageAccessFromFileURLsQuirk(needsQuirk);
>+    WebKit::toImpl(preferencesRef)->setNeedsStorageAccessFromFileURLsQuirk(needsQuirk);
> }
> 
> bool WKPreferencesGetNeedsStorageAccessFromFileURLsQuirk(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->needsStorageAccessFromFileURLsQuirk();
>+    return WebKit::toImpl(preferencesRef)->needsStorageAccessFromFileURLsQuirk();
> }
> 
> void WKPreferencesSetHixie76WebSocketProtocolEnabled(WKPreferencesRef, bool /*enabled*/)
>@@ -770,162 +770,162 @@ bool WKPreferencesGetHixie76WebSocketProtocolEnabled(WKPreferencesRef)
> 
> void WKPreferencesSetMediaPlaybackRequiresUserGesture(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setRequiresUserGestureForMediaPlayback(flag);
>+    WebKit::toImpl(preferencesRef)->setRequiresUserGestureForMediaPlayback(flag);
> }
> 
> bool WKPreferencesGetMediaPlaybackRequiresUserGesture(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->requiresUserGestureForMediaPlayback();
>+    return WebKit::toImpl(preferencesRef)->requiresUserGestureForMediaPlayback();
> }
> 
> void WKPreferencesSetVideoPlaybackRequiresUserGesture(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setRequiresUserGestureForVideoPlayback(flag);
>+    WebKit::toImpl(preferencesRef)->setRequiresUserGestureForVideoPlayback(flag);
> }
> 
> bool WKPreferencesGetVideoPlaybackRequiresUserGesture(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->requiresUserGestureForVideoPlayback();
>+    return WebKit::toImpl(preferencesRef)->requiresUserGestureForVideoPlayback();
> }
> 
> void WKPreferencesSetAudioPlaybackRequiresUserGesture(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setRequiresUserGestureForAudioPlayback(flag);
>+    WebKit::toImpl(preferencesRef)->setRequiresUserGestureForAudioPlayback(flag);
> }
> 
> bool WKPreferencesGetAudioPlaybackRequiresUserGesture(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->requiresUserGestureForAudioPlayback();
>+    return WebKit::toImpl(preferencesRef)->requiresUserGestureForAudioPlayback();
> }
> 
> void WKPreferencesSetMainContentUserGestureOverrideEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setMainContentUserGestureOverrideEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setMainContentUserGestureOverrideEnabled(flag);
> }
> 
> bool WKPreferencesGetMainContentUserGestureOverrideEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mainContentUserGestureOverrideEnabled();
>+    return WebKit::toImpl(preferencesRef)->mainContentUserGestureOverrideEnabled();
> }
> 
> void WKPreferencesSetMediaPlaybackAllowsInline(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAllowsInlineMediaPlayback(flag);
>+    WebKit::toImpl(preferencesRef)->setAllowsInlineMediaPlayback(flag);
> }
> 
> bool WKPreferencesGetMediaPlaybackAllowsInline(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowsInlineMediaPlayback();
>+    return WebKit::toImpl(preferencesRef)->allowsInlineMediaPlayback();
> }
> 
> void WKPreferencesSetInlineMediaPlaybackRequiresPlaysInlineAttribute(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setInlineMediaPlaybackRequiresPlaysInlineAttribute(flag);
>+    WebKit::toImpl(preferencesRef)->setInlineMediaPlaybackRequiresPlaysInlineAttribute(flag);
> }
> 
> bool WKPreferencesGetInlineMediaPlaybackRequiresPlaysInlineAttribute(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->inlineMediaPlaybackRequiresPlaysInlineAttribute();
>+    return WebKit::toImpl(preferencesRef)->inlineMediaPlaybackRequiresPlaysInlineAttribute();
> }
> 
> void WKPreferencesSetBeaconAPIEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setBeaconAPIEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setBeaconAPIEnabled(flag);
> }
> 
> bool WKPreferencesGetBeaconAPIEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->beaconAPIEnabled();
>+    return WebKit::toImpl(preferencesRef)->beaconAPIEnabled();
> }
> 
> void WKPreferencesSetDirectoryUploadEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setDirectoryUploadEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setDirectoryUploadEnabled(flag);
> }
> 
> bool WKPreferencesGetDirectoryUploadEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->directoryUploadEnabled();
>+    return WebKit::toImpl(preferencesRef)->directoryUploadEnabled();
> }
> 
> void WKPreferencesSetMediaControlsScaleWithPageZoom(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setMediaControlsScaleWithPageZoom(flag);
>+    WebKit::toImpl(preferencesRef)->setMediaControlsScaleWithPageZoom(flag);
> }
> 
> bool WKPreferencesGetMediaControlsScaleWithPageZoom(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaControlsScaleWithPageZoom();
>+    return WebKit::toImpl(preferencesRef)->mediaControlsScaleWithPageZoom();
> }
> 
> void WKPreferencesSetModernMediaControlsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setModernMediaControlsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setModernMediaControlsEnabled(flag);
> }
> 
> bool WKPreferencesGetModernMediaControlsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->modernMediaControlsEnabled();
>+    return WebKit::toImpl(preferencesRef)->modernMediaControlsEnabled();
> }
> 
> void WKPreferencesSetWebAuthenticationEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setWebAuthenticationEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setWebAuthenticationEnabled(flag);
> }
> 
> bool WKPreferencesGetWebAuthenticationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webAuthenticationEnabled();
>+    return WebKit::toImpl(preferencesRef)->webAuthenticationEnabled();
> }
> 
> void WKPreferencesSetInvisibleMediaAutoplayPermitted(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setInvisibleAutoplayNotPermitted(!flag);
>+    WebKit::toImpl(preferencesRef)->setInvisibleAutoplayNotPermitted(!flag);
> }
> 
> bool WKPreferencesGetInvisibleMediaAutoplayPermitted(WKPreferencesRef preferencesRef)
> {
>-    return !toImpl(preferencesRef)->invisibleAutoplayNotPermitted();
>+    return !WebKit::toImpl(preferencesRef)->invisibleAutoplayNotPermitted();
> }
> 
> void WKPreferencesSetShowsToolTipOverTruncatedText(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setShowsToolTipOverTruncatedText(flag);
>+    WebKit::toImpl(preferencesRef)->setShowsToolTipOverTruncatedText(flag);
> }
> 
> bool WKPreferencesGetShowsToolTipOverTruncatedText(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->showsToolTipOverTruncatedText();
>+    return WebKit::toImpl(preferencesRef)->showsToolTipOverTruncatedText();
> }
> 
> void WKPreferencesSetMockScrollbarsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setMockScrollbarsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setMockScrollbarsEnabled(flag);
> }
> 
> bool WKPreferencesGetMockScrollbarsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mockScrollbarsEnabled();
>+    return WebKit::toImpl(preferencesRef)->mockScrollbarsEnabled();
> }
> 
> void WKPreferencesSetAttachmentElementEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAttachmentElementEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAttachmentElementEnabled(flag);
> }
> 
> bool WKPreferencesGetAttachmentElementEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->attachmentElementEnabled();
>+    return WebKit::toImpl(preferencesRef)->attachmentElementEnabled();
> }
> 
> void WKPreferencesSetWebAudioEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setWebAudioEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setWebAudioEnabled(enabled);
> }
> 
> bool WKPreferencesGetWebAudioEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webAudioEnabled();
>+    return WebKit::toImpl(preferencesRef)->webAudioEnabled();
> }
> 
> void WKPreferencesSetApplicationChromeModeEnabled(WKPreferencesRef, bool)
>@@ -952,189 +952,189 @@ bool WKPreferencesGetInspectorUsesWebKitUserInterface(WKPreferencesRef)
> 
> void WKPreferencesSetSuppressesIncrementalRendering(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setSuppressesIncrementalRendering(enabled);
>+    WebKit::toImpl(preferencesRef)->setSuppressesIncrementalRendering(enabled);
> }
> 
> bool WKPreferencesGetSuppressesIncrementalRendering(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->suppressesIncrementalRendering();
>+    return WebKit::toImpl(preferencesRef)->suppressesIncrementalRendering();
> }
> 
> void WKPreferencesSetBackspaceKeyNavigationEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setBackspaceKeyNavigationEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setBackspaceKeyNavigationEnabled(enabled);
> }
> 
> bool WKPreferencesGetBackspaceKeyNavigationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->backspaceKeyNavigationEnabled();
>+    return WebKit::toImpl(preferencesRef)->backspaceKeyNavigationEnabled();
> }
> 
> void WKPreferencesSetCaretBrowsingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setCaretBrowsingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setCaretBrowsingEnabled(enabled);
> }
> 
> bool WKPreferencesGetCaretBrowsingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->caretBrowsingEnabled();
>+    return WebKit::toImpl(preferencesRef)->caretBrowsingEnabled();
> }
> 
> void WKPreferencesSetShouldDisplaySubtitles(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setShouldDisplaySubtitles(enabled);
>+    WebKit::toImpl(preferencesRef)->setShouldDisplaySubtitles(enabled);
> }
> 
> bool WKPreferencesGetShouldDisplaySubtitles(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldDisplaySubtitles();
>+    return WebKit::toImpl(preferencesRef)->shouldDisplaySubtitles();
> }
> 
> void WKPreferencesSetShouldDisplayCaptions(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setShouldDisplayCaptions(enabled);
>+    WebKit::toImpl(preferencesRef)->setShouldDisplayCaptions(enabled);
> }
> 
> bool WKPreferencesGetShouldDisplayCaptions(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldDisplayCaptions();
>+    return WebKit::toImpl(preferencesRef)->shouldDisplayCaptions();
> }
> 
> void WKPreferencesSetShouldDisplayTextDescriptions(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setShouldDisplayTextDescriptions(enabled);
>+    WebKit::toImpl(preferencesRef)->setShouldDisplayTextDescriptions(enabled);
> }
> 
> bool WKPreferencesGetShouldDisplayTextDescriptions(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldDisplayTextDescriptions();
>+    return WebKit::toImpl(preferencesRef)->shouldDisplayTextDescriptions();
> }
> 
> void WKPreferencesSetNotificationsEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setNotificationsEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setNotificationsEnabled(enabled);
> }
> 
> bool WKPreferencesGetNotificationsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->notificationsEnabled();
>+    return WebKit::toImpl(preferencesRef)->notificationsEnabled();
> }
> 
> void WKPreferencesSetShouldRespectImageOrientation(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setShouldRespectImageOrientation(enabled);
>+    WebKit::toImpl(preferencesRef)->setShouldRespectImageOrientation(enabled);
> }
> 
> bool WKPreferencesGetShouldRespectImageOrientation(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldRespectImageOrientation();
>+    return WebKit::toImpl(preferencesRef)->shouldRespectImageOrientation();
> }
> 
> void WKPreferencesSetRequestAnimationFrameEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setRequestAnimationFrameEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setRequestAnimationFrameEnabled(flag);
> }
> 
> bool WKPreferencesGetRequestAnimationFrameEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->requestAnimationFrameEnabled();
>+    return WebKit::toImpl(preferencesRef)->requestAnimationFrameEnabled();
> }
> 
> void WKPreferencesSetStorageBlockingPolicy(WKPreferencesRef preferencesRef, WKStorageBlockingPolicy policy)
> {
>-    toImpl(preferencesRef)->setStorageBlockingPolicy(toStorageBlockingPolicy(policy));
>+    WebKit::toImpl(preferencesRef)->setStorageBlockingPolicy(toStorageBlockingPolicy(policy));
> }
> 
> WKStorageBlockingPolicy WKPreferencesGetStorageBlockingPolicy(WKPreferencesRef preferencesRef)
> {
>-    return toAPI(static_cast<WebCore::SecurityOrigin::StorageBlockingPolicy>(toImpl(preferencesRef)->storageBlockingPolicy()));
>+    return toAPI(static_cast<WebCore::SecurityOrigin::StorageBlockingPolicy>(WebKit::toImpl(preferencesRef)->storageBlockingPolicy()));
> }
> 
> void WKPreferencesResetTestRunnerOverrides(WKPreferencesRef preferencesRef)
> {
>     // Currently we reset the overrides on the web process when preferencesDidChange() is called. Since WTR preferences
>     // are usually always the same (in the UI process), they are not sent to web process, not triggering the reset.
>-    toImpl(preferencesRef)->forceUpdate();
>+    WebKit::toImpl(preferencesRef)->forceUpdate();
> }
> 
> void WKPreferencesSetDiagnosticLoggingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setDiagnosticLoggingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setDiagnosticLoggingEnabled(enabled);
> }
> 
> bool WKPreferencesGetDiagnosticLoggingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->diagnosticLoggingEnabled();
>+    return WebKit::toImpl(preferencesRef)->diagnosticLoggingEnabled();
> }
> 
> void WKPreferencesSetAsynchronousPluginInitializationEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAsynchronousPluginInitializationEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAsynchronousPluginInitializationEnabled(enabled);
> }
> 
> bool WKPreferencesGetAsynchronousPluginInitializationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->asynchronousPluginInitializationEnabled();
>+    return WebKit::toImpl(preferencesRef)->asynchronousPluginInitializationEnabled();
> }
> 
> void WKPreferencesSetAsynchronousPluginInitializationEnabledForAllPlugins(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAsynchronousPluginInitializationEnabledForAllPlugins(enabled);
>+    WebKit::toImpl(preferencesRef)->setAsynchronousPluginInitializationEnabledForAllPlugins(enabled);
> }
> 
> bool WKPreferencesGetAsynchronousPluginInitializationEnabledForAllPlugins(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->asynchronousPluginInitializationEnabledForAllPlugins();
>+    return WebKit::toImpl(preferencesRef)->asynchronousPluginInitializationEnabledForAllPlugins();
> }
> 
> void WKPreferencesSetArtificialPluginInitializationDelayEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setArtificialPluginInitializationDelayEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setArtificialPluginInitializationDelayEnabled(enabled);
> }
> 
> bool WKPreferencesGetArtificialPluginInitializationDelayEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->artificialPluginInitializationDelayEnabled();
>+    return WebKit::toImpl(preferencesRef)->artificialPluginInitializationDelayEnabled();
> }
> 
> void WKPreferencesSetTabToLinksEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setTabToLinksEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setTabToLinksEnabled(enabled);
> }
> 
> bool WKPreferencesGetTabToLinksEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->tabToLinksEnabled();
>+    return WebKit::toImpl(preferencesRef)->tabToLinksEnabled();
> }
> 
> void WKPreferencesSetInteractiveFormValidationEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setInteractiveFormValidationEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setInteractiveFormValidationEnabled(enabled);
> }
> 
> bool WKPreferencesGetInteractiveFormValidationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->interactiveFormValidationEnabled();
>+    return WebKit::toImpl(preferencesRef)->interactiveFormValidationEnabled();
> }
> 
> void WKPreferencesSetScrollingPerformanceLoggingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setScrollingPerformanceLoggingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setScrollingPerformanceLoggingEnabled(enabled);
> }
> 
> bool WKPreferencesGetScrollingPerformanceLoggingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->scrollingPerformanceLoggingEnabled();
>+    return WebKit::toImpl(preferencesRef)->scrollingPerformanceLoggingEnabled();
> }
> 
> void WKPreferencesSetPlugInSnapshottingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPlugInSnapshottingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPlugInSnapshottingEnabled(enabled);
> }
> 
> bool WKPreferencesGetPlugInSnapshottingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->plugInSnapshottingEnabled();
>+    return WebKit::toImpl(preferencesRef)->plugInSnapshottingEnabled();
> }
> 
> void WKPreferencesSetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef preferencesRef, bool enabled)
>@@ -1142,202 +1142,202 @@ void WKPreferencesSetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef
> #if ENABLE(NETSCAPE_PLUGIN_API) && PLATFORM(MAC)
>     WebKit::PluginProcessManager::singleton().setExperimentalPlugInSandboxProfilesEnabled(enabled);
> #endif
>-    toImpl(preferencesRef)->setExperimentalPlugInSandboxProfilesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setExperimentalPlugInSandboxProfilesEnabled(enabled);
> }
> 
> bool WKPreferencesGetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->experimentalPlugInSandboxProfilesEnabled();
>+    return WebKit::toImpl(preferencesRef)->experimentalPlugInSandboxProfilesEnabled();
> }
> 
> void WKPreferencesSetSnapshotAllPlugIns(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setSnapshotAllPlugIns(enabled);
>+    WebKit::toImpl(preferencesRef)->setSnapshotAllPlugIns(enabled);
> }
> 
> bool WKPreferencesGetSnapshotAllPlugIns(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->snapshotAllPlugIns();
>+    return WebKit::toImpl(preferencesRef)->snapshotAllPlugIns();
> }
> 
> void WKPreferencesSetAutostartOriginPlugInSnapshottingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAutostartOriginPlugInSnapshottingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAutostartOriginPlugInSnapshottingEnabled(enabled);
> }
> 
> bool WKPreferencesGetAutostartOriginPlugInSnapshottingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->autostartOriginPlugInSnapshottingEnabled();
>+    return WebKit::toImpl(preferencesRef)->autostartOriginPlugInSnapshottingEnabled();
> }
> 
> void WKPreferencesSetPrimaryPlugInSnapshotDetectionEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPrimaryPlugInSnapshotDetectionEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPrimaryPlugInSnapshotDetectionEnabled(enabled);
> }
> 
> bool WKPreferencesGetPrimaryPlugInSnapshotDetectionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->primaryPlugInSnapshotDetectionEnabled();
>+    return WebKit::toImpl(preferencesRef)->primaryPlugInSnapshotDetectionEnabled();
> }
> 
> void WKPreferencesSetPDFPluginEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPDFPluginEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPDFPluginEnabled(enabled);
> }
> 
> bool WKPreferencesGetPDFPluginEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->pdfPluginEnabled();
>+    return WebKit::toImpl(preferencesRef)->pdfPluginEnabled();
> }
> 
> void WKPreferencesSetEncodingDetectorEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setUsesEncodingDetector(enabled);
>+    WebKit::toImpl(preferencesRef)->setUsesEncodingDetector(enabled);
> }
> 
> bool WKPreferencesGetEncodingDetectorEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->usesEncodingDetector();
>+    return WebKit::toImpl(preferencesRef)->usesEncodingDetector();
> }
> 
> void WKPreferencesSetTextAutosizingEnabled(WKPreferencesRef preferencesRef, bool textAutosizingEnabled)
> {
>-    toImpl(preferencesRef)->setTextAutosizingEnabled(textAutosizingEnabled);
>+    WebKit::toImpl(preferencesRef)->setTextAutosizingEnabled(textAutosizingEnabled);
> }
> 
> bool WKPreferencesGetTextAutosizingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->textAutosizingEnabled();
>+    return WebKit::toImpl(preferencesRef)->textAutosizingEnabled();
> }
> 
> void WKPreferencesSetAggressiveTileRetentionEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAggressiveTileRetentionEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setAggressiveTileRetentionEnabled(enabled);
> }
> 
> bool WKPreferencesGetAggressiveTileRetentionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->aggressiveTileRetentionEnabled();
>+    return WebKit::toImpl(preferencesRef)->aggressiveTileRetentionEnabled();
> }
> 
> void WKPreferencesSetLogsPageMessagesToSystemConsoleEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setLogsPageMessagesToSystemConsoleEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setLogsPageMessagesToSystemConsoleEnabled(enabled);
> }
> 
> bool WKPreferencesGetLogsPageMessagesToSystemConsoleEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->logsPageMessagesToSystemConsoleEnabled();
>+    return WebKit::toImpl(preferencesRef)->logsPageMessagesToSystemConsoleEnabled();
> }
> 
> void WKPreferencesSetPageVisibilityBasedProcessSuppressionEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPageVisibilityBasedProcessSuppressionEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPageVisibilityBasedProcessSuppressionEnabled(enabled);
> }
> 
> bool WKPreferencesGetPageVisibilityBasedProcessSuppressionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->pageVisibilityBasedProcessSuppressionEnabled();
>+    return WebKit::toImpl(preferencesRef)->pageVisibilityBasedProcessSuppressionEnabled();
> }
> 
> void WKPreferencesSetSmartInsertDeleteEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setSmartInsertDeleteEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setSmartInsertDeleteEnabled(enabled);
> }
> 
> bool WKPreferencesGetSmartInsertDeleteEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->smartInsertDeleteEnabled();
>+    return WebKit::toImpl(preferencesRef)->smartInsertDeleteEnabled();
> }
> 
> void WKPreferencesSetSelectTrailingWhitespaceEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setSelectTrailingWhitespaceEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setSelectTrailingWhitespaceEnabled(enabled);
> }
> 
> bool WKPreferencesGetSelectTrailingWhitespaceEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->selectTrailingWhitespaceEnabled();
>+    return WebKit::toImpl(preferencesRef)->selectTrailingWhitespaceEnabled();
> }
> 
> void WKPreferencesSetShowsURLsInToolTipsEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setShowsURLsInToolTipsEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setShowsURLsInToolTipsEnabled(enabled);
> }
> 
> bool WKPreferencesGetShowsURLsInToolTipsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->showsURLsInToolTipsEnabled();
>+    return WebKit::toImpl(preferencesRef)->showsURLsInToolTipsEnabled();
> }
> 
> void WKPreferencesSetHiddenPageDOMTimerThrottlingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setHiddenPageDOMTimerThrottlingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setHiddenPageDOMTimerThrottlingEnabled(enabled);
> }
> 
> void WKPreferencesSetHiddenPageDOMTimerThrottlingAutoIncreases(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setHiddenPageDOMTimerThrottlingAutoIncreases(enabled);
>+    WebKit::toImpl(preferencesRef)->setHiddenPageDOMTimerThrottlingAutoIncreases(enabled);
> }
> 
> bool WKPreferencesGetHiddenPageDOMTimerThrottlingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->hiddenPageDOMTimerThrottlingEnabled();
>+    return WebKit::toImpl(preferencesRef)->hiddenPageDOMTimerThrottlingEnabled();
> }
> 
> bool WKPreferencesGetHiddenPageDOMTimerThrottlingAutoIncreases(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->hiddenPageDOMTimerThrottlingAutoIncreases();
>+    return WebKit::toImpl(preferencesRef)->hiddenPageDOMTimerThrottlingAutoIncreases();
> }
> 
> void WKPreferencesSetHiddenPageCSSAnimationSuspensionEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setHiddenPageCSSAnimationSuspensionEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setHiddenPageCSSAnimationSuspensionEnabled(enabled);
> }
> 
> bool WKPreferencesGetHiddenPageCSSAnimationSuspensionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->hiddenPageCSSAnimationSuspensionEnabled();
>+    return WebKit::toImpl(preferencesRef)->hiddenPageCSSAnimationSuspensionEnabled();
> }
> 
> void WKPreferencesSetIncrementalRenderingSuppressionTimeout(WKPreferencesRef preferencesRef, double timeout)
> {
>-    toImpl(preferencesRef)->setIncrementalRenderingSuppressionTimeout(timeout);
>+    WebKit::toImpl(preferencesRef)->setIncrementalRenderingSuppressionTimeout(timeout);
> }
> 
> double WKPreferencesGetIncrementalRenderingSuppressionTimeout(WKPreferencesRef preferencesRef)
> {
>-    return toAPI(toImpl(preferencesRef)->incrementalRenderingSuppressionTimeout());
>+    return toAPI(WebKit::toImpl(preferencesRef)->incrementalRenderingSuppressionTimeout());
> }
> 
> void WKPreferencesSetThreadedScrollingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setThreadedScrollingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setThreadedScrollingEnabled(enabled);
> }
> 
> bool WKPreferencesGetThreadedScrollingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->threadedScrollingEnabled();
>+    return WebKit::toImpl(preferencesRef)->threadedScrollingEnabled();
> }
> 
> void WKPreferencesSetSimpleLineLayoutEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setSimpleLineLayoutEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setSimpleLineLayoutEnabled(flag);
> }
> 
> bool WKPreferencesGetSimpleLineLayoutEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->simpleLineLayoutEnabled();
>+    return WebKit::toImpl(preferencesRef)->simpleLineLayoutEnabled();
> }
> 
> void WKPreferencesSetSimpleLineLayoutDebugBordersEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setSimpleLineLayoutDebugBordersEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setSimpleLineLayoutDebugBordersEnabled(flag);
> }
> 
> bool WKPreferencesGetSimpleLineLayoutDebugBordersEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->simpleLineLayoutDebugBordersEnabled();
>+    return WebKit::toImpl(preferencesRef)->simpleLineLayoutDebugBordersEnabled();
> }
> 
> void WKPreferencesSetNewBlockInsideInlineModelEnabled(WKPreferencesRef, bool)
>@@ -1353,62 +1353,62 @@ bool WKPreferencesGetNewBlockInsideInlineModelEnabled(WKPreferencesRef)
> 
> void WKPreferencesSetDeferredCSSParserEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setDeferredCSSParserEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setDeferredCSSParserEnabled(flag);
> }
> 
> bool WKPreferencesGetDeferredCSSParserEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->deferredCSSParserEnabled();
>+    return WebKit::toImpl(preferencesRef)->deferredCSSParserEnabled();
> }
> 
> void WKPreferencesSetSubpixelCSSOMElementMetricsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setSubpixelCSSOMElementMetricsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setSubpixelCSSOMElementMetricsEnabled(flag);
> }
> 
> bool WKPreferencesGetSubpixelCSSOMElementMetricsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->subpixelCSSOMElementMetricsEnabled();
>+    return WebKit::toImpl(preferencesRef)->subpixelCSSOMElementMetricsEnabled();
> }
> 
> void WKPreferencesSetUseGiantTiles(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setUseGiantTiles(flag);
>+    WebKit::toImpl(preferencesRef)->setUseGiantTiles(flag);
> }
> 
> bool WKPreferencesGetUseGiantTiles(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->useGiantTiles();
>+    return WebKit::toImpl(preferencesRef)->useGiantTiles();
> }
> 
> void WKPreferencesSetMediaDevicesEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setMediaDevicesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setMediaDevicesEnabled(enabled);
> }
> 
> bool WKPreferencesGetMediaDevicesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaDevicesEnabled();
>+    return WebKit::toImpl(preferencesRef)->mediaDevicesEnabled();
> }
> 
> void WKPreferencesSetMediaStreamEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setMediaStreamEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setMediaStreamEnabled(enabled);
> }
> 
> bool WKPreferencesGetMediaStreamEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaStreamEnabled();
>+    return WebKit::toImpl(preferencesRef)->mediaStreamEnabled();
> }
> 
> void WKPreferencesSetPeerConnectionEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setPeerConnectionEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setPeerConnectionEnabled(enabled);
> }
> 
> bool WKPreferencesGetPeerConnectionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->peerConnectionEnabled();
>+    return WebKit::toImpl(preferencesRef)->peerConnectionEnabled();
> }
> 
> void WKPreferencesSetWebRTCLegacyAPIEnabled(WKPreferencesRef, bool)
>@@ -1422,112 +1422,112 @@ bool WKPreferencesGetWebRTCLegacyAPIEnabled(WKPreferencesRef)
> 
> void WKPreferencesSetWebRTCMDNSICECandidatesEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setWebRTCMDNSICECandidatesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setWebRTCMDNSICECandidatesEnabled(enabled);
> }
> 
> bool WKPreferencesGetWebRTCMDNSICECandidatesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webRTCMDNSICECandidatesEnabled();
>+    return WebKit::toImpl(preferencesRef)->webRTCMDNSICECandidatesEnabled();
> }
> 
> void WKPreferencesSetSpatialNavigationEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setSpatialNavigationEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setSpatialNavigationEnabled(enabled);
> }
> 
> bool WKPreferencesGetSpatialNavigationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->spatialNavigationEnabled();
>+    return WebKit::toImpl(preferencesRef)->spatialNavigationEnabled();
> }
> 
> void WKPreferencesSetMediaSourceEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setMediaSourceEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setMediaSourceEnabled(enabled);
> }
> 
> bool WKPreferencesGetMediaSourceEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaSourceEnabled();
>+    return WebKit::toImpl(preferencesRef)->mediaSourceEnabled();
> }
> 
> void WKPreferencesSetSourceBufferChangeTypeEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setSourceBufferChangeTypeEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setSourceBufferChangeTypeEnabled(enabled);
> }
> 
> bool WKPreferencesGetSourceBufferChangeTypeEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->sourceBufferChangeTypeEnabled();
>+    return WebKit::toImpl(preferencesRef)->sourceBufferChangeTypeEnabled();
> }
> 
> void WKPreferencesSetViewGestureDebuggingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setViewGestureDebuggingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setViewGestureDebuggingEnabled(enabled);
> }
> 
> bool WKPreferencesGetViewGestureDebuggingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->viewGestureDebuggingEnabled();
>+    return WebKit::toImpl(preferencesRef)->viewGestureDebuggingEnabled();
> }
> 
> void WKPreferencesSetShouldConvertPositionStyleOnCopy(WKPreferencesRef preferencesRef, bool convert)
> {
>-    toImpl(preferencesRef)->setShouldConvertPositionStyleOnCopy(convert);
>+    WebKit::toImpl(preferencesRef)->setShouldConvertPositionStyleOnCopy(convert);
> }
> 
> bool WKPreferencesGetShouldConvertPositionStyleOnCopy(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldConvertPositionStyleOnCopy();
>+    return WebKit::toImpl(preferencesRef)->shouldConvertPositionStyleOnCopy();
> }
> 
> void WKPreferencesSetTelephoneNumberParsingEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setTelephoneNumberParsingEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setTelephoneNumberParsingEnabled(enabled);
> }
> 
> bool WKPreferencesGetTelephoneNumberParsingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->telephoneNumberParsingEnabled();
>+    return WebKit::toImpl(preferencesRef)->telephoneNumberParsingEnabled();
> }
> 
> void WKPreferencesSetEnableInheritURIQueryComponent(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setEnableInheritURIQueryComponent(enabled);
>+    WebKit::toImpl(preferencesRef)->setEnableInheritURIQueryComponent(enabled);
> }
> 
> bool WKPreferencesGetEnableInheritURIQueryComponent(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->enableInheritURIQueryComponent();
>+    return WebKit::toImpl(preferencesRef)->enableInheritURIQueryComponent();
> }
> 
> void WKPreferencesSetServiceControlsEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setServiceControlsEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setServiceControlsEnabled(enabled);
> }
> 
> bool WKPreferencesGetServiceControlsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->serviceControlsEnabled();
>+    return WebKit::toImpl(preferencesRef)->serviceControlsEnabled();
> }
> 
> void WKPreferencesSetImageControlsEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setImageControlsEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setImageControlsEnabled(enabled);
> }
> 
> bool WKPreferencesGetImageControlsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->imageControlsEnabled();
>+    return WebKit::toImpl(preferencesRef)->imageControlsEnabled();
> }
> 
> void WKPreferencesSetGamepadsEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setGamepadsEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setGamepadsEnabled(enabled);
> }
> 
> bool WKPreferencesGetGamepadsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->gamepadsEnabled();
>+    return WebKit::toImpl(preferencesRef)->gamepadsEnabled();
> }
> 
> // FIXME: Remove these when possible.
>@@ -1542,12 +1542,12 @@ bool WKPreferencesGetLongMousePressEnabled(WKPreferencesRef preferencesRef)
> 
> void WKPreferencesSetMinimumZoomFontSize(WKPreferencesRef preferencesRef, double size)
> {
>-    toImpl(preferencesRef)->setMinimumZoomFontSize(size);
>+    WebKit::toImpl(preferencesRef)->setMinimumZoomFontSize(size);
> }
> 
> double WKPreferencesGetMinimumZoomFontSize(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->minimumZoomFontSize();
>+    return WebKit::toImpl(preferencesRef)->minimumZoomFontSize();
> }
> 
> void WKPreferencesSetAntialiasedFontDilationEnabled(WKPreferencesRef, bool)
>@@ -1562,252 +1562,252 @@ bool WKPreferencesGetAntialiasedFontDilationEnabled(WKPreferencesRef)
> 
> void WKPreferencesSetVisibleDebugOverlayRegions(WKPreferencesRef preferencesRef, WKDebugOverlayRegions visibleRegions)
> {
>-    toImpl(preferencesRef)->setVisibleDebugOverlayRegions(visibleRegions);
>+    WebKit::toImpl(preferencesRef)->setVisibleDebugOverlayRegions(visibleRegions);
> }
> 
> WKDebugOverlayRegions WKPreferencesGetVisibleDebugOverlayRegions(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->visibleDebugOverlayRegions();
>+    return WebKit::toImpl(preferencesRef)->visibleDebugOverlayRegions();
> }
> 
> void WKPreferencesSetIgnoreViewportScalingConstraints(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setIgnoreViewportScalingConstraints(enabled);
>+    WebKit::toImpl(preferencesRef)->setIgnoreViewportScalingConstraints(enabled);
> }
> 
> bool WKPreferencesGetIgnoreViewportScalingConstraints(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->ignoreViewportScalingConstraints();
>+    return WebKit::toImpl(preferencesRef)->ignoreViewportScalingConstraints();
> }
> 
> void WKPreferencesSetMetaRefreshEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setHTTPEquivEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setHTTPEquivEnabled(enabled);
> }
> 
> bool WKPreferencesGetMetaRefreshEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->httpEquivEnabled();
>+    return WebKit::toImpl(preferencesRef)->httpEquivEnabled();
> }
> 
> void WKPreferencesSetHTTPEquivEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setHTTPEquivEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setHTTPEquivEnabled(enabled);
> }
> 
> bool WKPreferencesGetHTTPEquivEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->httpEquivEnabled();
>+    return WebKit::toImpl(preferencesRef)->httpEquivEnabled();
> }
> 
> void WKPreferencesSetAllowsAirPlayForMediaPlayback(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAllowsAirPlayForMediaPlayback(enabled);
>+    WebKit::toImpl(preferencesRef)->setAllowsAirPlayForMediaPlayback(enabled);
> }
> 
> bool WKPreferencesGetAllowsAirPlayForMediaPlayback(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowsAirPlayForMediaPlayback();
>+    return WebKit::toImpl(preferencesRef)->allowsAirPlayForMediaPlayback();
> }
> 
> void WKPreferencesSetUserInterfaceDirectionPolicy(WKPreferencesRef preferencesRef, _WKUserInterfaceDirectionPolicy userInterfaceDirectionPolicy)
> {
>-    toImpl(preferencesRef)->setUserInterfaceDirectionPolicy(userInterfaceDirectionPolicy);
>+    WebKit::toImpl(preferencesRef)->setUserInterfaceDirectionPolicy(userInterfaceDirectionPolicy);
> }
> 
> _WKUserInterfaceDirectionPolicy WKPreferencesGetUserInterfaceDirectionPolicy(WKPreferencesRef preferencesRef)
> {
>-    return static_cast<_WKUserInterfaceDirectionPolicy>(toImpl(preferencesRef)->userInterfaceDirectionPolicy());
>+    return static_cast<_WKUserInterfaceDirectionPolicy>(WebKit::toImpl(preferencesRef)->userInterfaceDirectionPolicy());
> }
> 
> void WKPreferencesSetResourceUsageOverlayVisible(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setResourceUsageOverlayVisible(enabled);
>+    WebKit::toImpl(preferencesRef)->setResourceUsageOverlayVisible(enabled);
> }
> 
> bool WKPreferencesGetResourceUsageOverlayVisible(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->resourceUsageOverlayVisible();
>+    return WebKit::toImpl(preferencesRef)->resourceUsageOverlayVisible();
> }
> 
> void WKPreferencesSetMockCaptureDevicesEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setMockCaptureDevicesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setMockCaptureDevicesEnabled(enabled);
> }
> 
> bool WKPreferencesGetMockCaptureDevicesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mockCaptureDevicesEnabled();
>+    return WebKit::toImpl(preferencesRef)->mockCaptureDevicesEnabled();
> }
> 
> void WKPreferencesSetICECandidateFilteringEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setICECandidateFilteringEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setICECandidateFilteringEnabled(enabled);
> }
> 
> bool WKPreferencesGetICECandidateFilteringEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->iceCandidateFilteringEnabled();
>+    return WebKit::toImpl(preferencesRef)->iceCandidateFilteringEnabled();
> }
> 
> void WKPreferencesSetEnumeratingAllNetworkInterfacesEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setEnumeratingAllNetworkInterfacesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setEnumeratingAllNetworkInterfacesEnabled(enabled);
> }
> 
> bool WKPreferencesGetEnumeratingAllNetworkInterfacesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->enumeratingAllNetworkInterfacesEnabled();
>+    return WebKit::toImpl(preferencesRef)->enumeratingAllNetworkInterfacesEnabled();
> }
> 
> void WKPreferencesSetMediaCaptureRequiresSecureConnection(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setMediaCaptureRequiresSecureConnection(enabled);
>+    WebKit::toImpl(preferencesRef)->setMediaCaptureRequiresSecureConnection(enabled);
> }
> 
> bool WKPreferencesGetMediaCaptureRequiresSecureConnection(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaCaptureRequiresSecureConnection();
>+    return WebKit::toImpl(preferencesRef)->mediaCaptureRequiresSecureConnection();
> }
> 
> void WKPreferencesSetInactiveMediaCaptureSteamRepromptIntervalInMinutes(WKPreferencesRef preferencesRef, double interval)
> {
>-    toImpl(preferencesRef)->setInactiveMediaCaptureSteamRepromptIntervalInMinutes(interval);
>+    WebKit::toImpl(preferencesRef)->setInactiveMediaCaptureSteamRepromptIntervalInMinutes(interval);
> }
> 
> double WKPreferencesGetInactiveMediaCaptureSteamRepromptIntervalInMinutes(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->inactiveMediaCaptureSteamRepromptIntervalInMinutes();
>+    return WebKit::toImpl(preferencesRef)->inactiveMediaCaptureSteamRepromptIntervalInMinutes();
> }
> 
> void WKPreferencesSetFetchAPIEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setFetchAPIEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setFetchAPIEnabled(flag);
> }
> 
> bool WKPreferencesGetFetchAPIEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->fetchAPIEnabled();
>+    return WebKit::toImpl(preferencesRef)->fetchAPIEnabled();
> }
> 
> void WKPreferencesSetDisplayContentsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setDisplayContentsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setDisplayContentsEnabled(flag);
> }
> 
> bool WKPreferencesGetDisplayContentsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->displayContentsEnabled();
>+    return WebKit::toImpl(preferencesRef)->displayContentsEnabled();
> }
> 
> void WKPreferencesSetDataTransferItemsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setDataTransferItemsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setDataTransferItemsEnabled(flag);
> }
> 
> bool WKPreferencesGetDataTransferItemsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->dataTransferItemsEnabled();
>+    return WebKit::toImpl(preferencesRef)->dataTransferItemsEnabled();
> }
> 
> void WKPreferencesSetCustomPasteboardDataEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCustomPasteboardDataEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setCustomPasteboardDataEnabled(flag);
> }
> 
> bool WKPreferencesGetCustomPasteboardDataEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->customPasteboardDataEnabled();
>+    return WebKit::toImpl(preferencesRef)->customPasteboardDataEnabled();
> }
> 
> void WKPreferencesSetWebShareEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setWebShareEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setWebShareEnabled(flag);
> }
> 
> bool WKPreferencesGetWebShareEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webShareEnabled();
>+    return WebKit::toImpl(preferencesRef)->webShareEnabled();
> }
> 
> void WKPreferencesSetDownloadAttributeEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setDownloadAttributeEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setDownloadAttributeEnabled(flag);
> }
> 
> bool WKPreferencesGetDownloadAttributeEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->downloadAttributeEnabled();
>+    return WebKit::toImpl(preferencesRef)->downloadAttributeEnabled();
> }
> 
> void WKPreferencesSetIntersectionObserverEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setIntersectionObserverEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setIntersectionObserverEnabled(flag);
> }
> 
> bool WKPreferencesGetIntersectionObserverEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->intersectionObserverEnabled();
>+    return WebKit::toImpl(preferencesRef)->intersectionObserverEnabled();
> }
> 
> void WKPreferencesSetMenuItemElementEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    return toImpl(preferencesRef)->setMenuItemElementEnabled(flag);
>+    return WebKit::toImpl(preferencesRef)->setMenuItemElementEnabled(flag);
> }
> 
> bool WKPreferencesGetMenuItemElementEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->menuItemElementEnabled();
>+    return WebKit::toImpl(preferencesRef)->menuItemElementEnabled();
> }
> 
> void WKPreferencesSetUserTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setUserTimingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setUserTimingEnabled(flag);
> }
> 
> bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->userTimingEnabled();
>+    return WebKit::toImpl(preferencesRef)->userTimingEnabled();
> }
> 
> void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setResourceTimingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setResourceTimingEnabled(flag);
> }
> 
> bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->resourceTimingEnabled();
>+    return WebKit::toImpl(preferencesRef)->resourceTimingEnabled();
> }
> 
> void WKPreferencesSetFetchAPIKeepAliveEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setFetchAPIKeepAliveEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setFetchAPIKeepAliveEnabled(flag);
> }
> 
> bool WKPreferencesGetFetchAPIKeepAliveEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->fetchAPIKeepAliveEnabled();
>+    return WebKit::toImpl(preferencesRef)->fetchAPIKeepAliveEnabled();
> }
> 
> void WKPreferencesSetSelectionPaintingWithoutSelectionGapsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setSelectionPaintingWithoutSelectionGapsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setSelectionPaintingWithoutSelectionGapsEnabled(flag);
> }
> 
> bool WKPreferencesGetSelectionPaintingWithoutSelectionGapsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->selectionPaintingWithoutSelectionGapsEnabled();
>+    return WebKit::toImpl(preferencesRef)->selectionPaintingWithoutSelectionGapsEnabled();
> }
> 
> void WKPreferencesSetAllowsPictureInPictureMediaPlayback(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setAllowsPictureInPictureMediaPlayback(enabled);
>+    WebKit::toImpl(preferencesRef)->setAllowsPictureInPictureMediaPlayback(enabled);
> }
> 
> bool WKPreferencesGetAllowsPictureInPictureMediaPlayback(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowsPictureInPictureMediaPlayback();
>+    return WebKit::toImpl(preferencesRef)->allowsPictureInPictureMediaPlayback();
> }
> 
> WK_EXPORT bool WKPreferencesGetApplePayEnabled(WKPreferencesRef preferencesRef)
>@@ -1832,270 +1832,270 @@ void WKPreferencesSetApplePayCapabilityDisclosureAllowed(WKPreferencesRef prefer
> 
> void WKPreferencesSetLinkPreloadEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setLinkPreloadEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setLinkPreloadEnabled(flag);
> }
> 
> bool WKPreferencesGetLinkPreloadEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->linkPreloadEnabled();
>+    return WebKit::toImpl(preferencesRef)->linkPreloadEnabled();
> }
> 
> void WKPreferencesSetMediaPreloadingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setMediaPreloadingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setMediaPreloadingEnabled(flag);
> }
> 
> bool WKPreferencesGetMediaPreloadingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaPreloadingEnabled();
>+    return WebKit::toImpl(preferencesRef)->mediaPreloadingEnabled();
> }
> 
> void WKPreferencesSetLargeImageAsyncDecodingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setLargeImageAsyncDecodingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setLargeImageAsyncDecodingEnabled(flag);
> }
> 
> bool WKPreferencesGetLargeImageAsyncDecodingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->largeImageAsyncDecodingEnabled();
>+    return WebKit::toImpl(preferencesRef)->largeImageAsyncDecodingEnabled();
> }
> 
> void WKPreferencesSetAnimatedImageAsyncDecodingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAnimatedImageAsyncDecodingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAnimatedImageAsyncDecodingEnabled(flag);
> }
> 
> bool WKPreferencesGetAnimatedImageAsyncDecodingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->animatedImageAsyncDecodingEnabled();
>+    return WebKit::toImpl(preferencesRef)->animatedImageAsyncDecodingEnabled();
> }
> 
> void WKPreferencesSetShouldSuppressKeyboardInputDuringProvisionalNavigation(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setShouldSuppressTextInputFromEditingDuringProvisionalNavigation(flag);
>+    WebKit::toImpl(preferencesRef)->setShouldSuppressTextInputFromEditingDuringProvisionalNavigation(flag);
> }
> 
> bool WKPreferencesGetShouldSuppressKeyboardInputDuringProvisionalNavigation(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldSuppressTextInputFromEditingDuringProvisionalNavigation();
>+    return WebKit::toImpl(preferencesRef)->shouldSuppressTextInputFromEditingDuringProvisionalNavigation();
> }
> 
> void WKPreferencesSetMediaUserGestureInheritsFromDocument(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setMediaUserGestureInheritsFromDocument(flag);
>+    WebKit::toImpl(preferencesRef)->setMediaUserGestureInheritsFromDocument(flag);
> }
> 
> bool WKPreferencesGetMediaUserGestureInheritsFromDocument(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaUserGestureInheritsFromDocument();
>+    return WebKit::toImpl(preferencesRef)->mediaUserGestureInheritsFromDocument();
> }
> 
> void WKPreferencesSetMediaContentTypesRequiringHardwareSupport(WKPreferencesRef preferencesRef, WKStringRef codecs)
> {
>-    toImpl(preferencesRef)->setMediaContentTypesRequiringHardwareSupport(toWTFString(codecs));
>+    WebKit::toImpl(preferencesRef)->setMediaContentTypesRequiringHardwareSupport(toWTFString(codecs));
> }
> 
> WKStringRef WKPreferencesCopyMediaContentTypesRequiringHardwareSupport(WKPreferencesRef preferencesRef)
> {
>-    return toCopiedAPI(toImpl(preferencesRef)->mediaContentTypesRequiringHardwareSupport());
>+    return toCopiedAPI(WebKit::toImpl(preferencesRef)->mediaContentTypesRequiringHardwareSupport());
> }
> 
> void WKPreferencesSetIsSecureContextAttributeEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setIsSecureContextAttributeEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setIsSecureContextAttributeEnabled(flag);
> }
> 
> bool WKPreferencesGetIsSecureContextAttributeEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->isSecureContextAttributeEnabled();
>+    return WebKit::toImpl(preferencesRef)->isSecureContextAttributeEnabled();
> }
> 
> bool WKPreferencesGetLegacyEncryptedMediaAPIEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->legacyEncryptedMediaAPIEnabled();
>+    return WebKit::toImpl(preferencesRef)->legacyEncryptedMediaAPIEnabled();
> }
> 
> void WKPreferencesSetLegacyEncryptedMediaAPIEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    return toImpl(preferencesRef)->setLegacyEncryptedMediaAPIEnabled(enabled);
>+    return WebKit::toImpl(preferencesRef)->setLegacyEncryptedMediaAPIEnabled(enabled);
> }
> 
> bool WKPreferencesGetAllowMediaContentTypesRequiringHardwareSupportAsFallback(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowMediaContentTypesRequiringHardwareSupportAsFallback();
>+    return WebKit::toImpl(preferencesRef)->allowMediaContentTypesRequiringHardwareSupportAsFallback();
> }
> 
> void WKPreferencesSetAllowMediaContentTypesRequiringHardwareSupportAsFallback(WKPreferencesRef preferencesRef, bool allow)
> {
>-    return toImpl(preferencesRef)->setAllowMediaContentTypesRequiringHardwareSupportAsFallback(allow);
>+    return WebKit::toImpl(preferencesRef)->setAllowMediaContentTypesRequiringHardwareSupportAsFallback(allow);
> }
> 
> void WKPreferencesSetInspectorAdditionsEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setInspectorAdditionsEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setInspectorAdditionsEnabled(flag);
> }
> 
> bool WKPreferencesGetInspectorAdditionsEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->inspectorAdditionsEnabled();
>+    return WebKit::toImpl(preferencesRef)->inspectorAdditionsEnabled();
> }
> 
> void WKPreferencesSetStorageAccessAPIEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setStorageAccessAPIEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setStorageAccessAPIEnabled(flag);
> }
> 
> bool WKPreferencesGetStorageAccessAPIEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->storageAccessAPIEnabled();
>+    return WebKit::toImpl(preferencesRef)->storageAccessAPIEnabled();
> }
> 
> void WKPreferencesSetAccessibilityObjectModelEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAccessibilityObjectModelEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAccessibilityObjectModelEnabled(flag);
> }
> 
> bool WKPreferencesGetAccessibilityObjectModelEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->accessibilityObjectModelEnabled();
>+    return WebKit::toImpl(preferencesRef)->accessibilityObjectModelEnabled();
> }
> 
> void WKPreferencesSetAriaReflectionEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAriaReflectionEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setAriaReflectionEnabled(flag);
> }
> 
> bool WKPreferencesGetAriaReflectionEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->ariaReflectionEnabled();
>+    return WebKit::toImpl(preferencesRef)->ariaReflectionEnabled();
> }
> 
> void WKPreferencesSetCSSOMViewScrollingAPIEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCSSOMViewScrollingAPIEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setCSSOMViewScrollingAPIEnabled(flag);
> }
> 
> bool WKPreferencesGetCSSOMViewScrollingAPIEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->cssOMViewScrollingAPIEnabled();
>+    return WebKit::toImpl(preferencesRef)->cssOMViewScrollingAPIEnabled();
> }
> 
> void WKPreferencesSetShouldAllowUserInstalledFonts(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setShouldAllowUserInstalledFonts(flag);
>+    WebKit::toImpl(preferencesRef)->setShouldAllowUserInstalledFonts(flag);
> }
> 
> bool WKPreferencesGetShouldAllowUserInstalledFonts(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->shouldAllowUserInstalledFonts();
>+    return WebKit::toImpl(preferencesRef)->shouldAllowUserInstalledFonts();
> }
> 
> void WKPreferencesSetMediaCapabilitiesEnabled(WKPreferencesRef preferencesRef, bool enabled)
> {
>-    toImpl(preferencesRef)->setMediaCapabilitiesEnabled(enabled);
>+    WebKit::toImpl(preferencesRef)->setMediaCapabilitiesEnabled(enabled);
> }
> 
> bool WKPreferencesGetMediaCapabilitiesEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->mediaCapabilitiesEnabled();
>+    return WebKit::toImpl(preferencesRef)->mediaCapabilitiesEnabled();
> }
> 
> void WKPreferencesSetAllowCrossOriginSubresourcesToAskForCredentials(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setAllowCrossOriginSubresourcesToAskForCredentials(flag);
>+    WebKit::toImpl(preferencesRef)->setAllowCrossOriginSubresourcesToAskForCredentials(flag);
> }
> 
> bool WKPreferencesGetAllowCrossOriginSubresourcesToAskForCredentials(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->allowCrossOriginSubresourcesToAskForCredentials();
>+    return WebKit::toImpl(preferencesRef)->allowCrossOriginSubresourcesToAskForCredentials();
> }
> 
> void WKPreferencesSetCrossOriginResourcePolicyEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCrossOriginResourcePolicyEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setCrossOriginResourcePolicyEnabled(flag);
> }
> 
> bool WKPreferencesGetCrossOriginResourcePolicyEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->crossOriginResourcePolicyEnabled();
>+    return WebKit::toImpl(preferencesRef)->crossOriginResourcePolicyEnabled();
> }
> 
> void WKPreferencesSetRestrictedHTTPResponseAccess(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setRestrictedHTTPResponseAccess(flag);
>+    WebKit::toImpl(preferencesRef)->setRestrictedHTTPResponseAccess(flag);
> }
> 
> bool WKPreferencesGetRestrictedHTTPResponseAccess(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->restrictedHTTPResponseAccess();
>+    return WebKit::toImpl(preferencesRef)->restrictedHTTPResponseAccess();
> }
> 
> void WKPreferencesSetServerTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setServerTimingEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setServerTimingEnabled(flag);
> }
> 
> bool WKPreferencesGetServerTimingEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->serverTimingEnabled();
>+    return WebKit::toImpl(preferencesRef)->serverTimingEnabled();
> }
> 
> void WKPreferencesSetColorFilterEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setColorFilterEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setColorFilterEnabled(flag);
> }
> 
> bool WKPreferencesGetColorFilterEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->colorFilterEnabled();
>+    return WebKit::toImpl(preferencesRef)->colorFilterEnabled();
> }
> 
> void WKPreferencesSetProcessSwapOnNavigationEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setProcessSwapOnCrossSiteNavigationEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setProcessSwapOnCrossSiteNavigationEnabled(flag);
> }
> 
> bool WKPreferencesGetProcessSwapOnNavigationEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->processSwapOnCrossSiteNavigationEnabled();
>+    return WebKit::toImpl(preferencesRef)->processSwapOnCrossSiteNavigationEnabled();
> }
> 
> void WKPreferencesSetPunchOutWhiteBackgroundsInDarkMode(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setPunchOutWhiteBackgroundsInDarkMode(flag);
>+    WebKit::toImpl(preferencesRef)->setPunchOutWhiteBackgroundsInDarkMode(flag);
> }
> 
> bool WKPreferencesGetPunchOutWhiteBackgroundsInDarkMode(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->punchOutWhiteBackgroundsInDarkMode();
>+    return WebKit::toImpl(preferencesRef)->punchOutWhiteBackgroundsInDarkMode();
> }
> 
> void WKPreferencesSetWebSQLDisabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setWebSQLDisabled(flag);
>+    WebKit::toImpl(preferencesRef)->setWebSQLDisabled(flag);
> }
> 
> bool WKPreferencesGetWebSQLDisabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->webSQLDisabled();
>+    return WebKit::toImpl(preferencesRef)->webSQLDisabled();
> }
> 
> void WKPreferencesSetCaptureAudioInUIProcessEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCaptureAudioInUIProcessEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setCaptureAudioInUIProcessEnabled(flag);
> }
> 
> bool WKPreferencesGetCaptureAudioInUIProcessEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->captureAudioInUIProcessEnabled();
>+    return WebKit::toImpl(preferencesRef)->captureAudioInUIProcessEnabled();
> }
> 
> void WKPreferencesSetCaptureVideoInUIProcessEnabled(WKPreferencesRef preferencesRef, bool flag)
> {
>-    toImpl(preferencesRef)->setCaptureVideoInUIProcessEnabled(flag);
>+    WebKit::toImpl(preferencesRef)->setCaptureVideoInUIProcessEnabled(flag);
> }
> 
> bool WKPreferencesGetCaptureVideoInUIProcessEnabled(WKPreferencesRef preferencesRef)
> {
>-    return toImpl(preferencesRef)->captureVideoInUIProcessEnabled();
>+    return WebKit::toImpl(preferencesRef)->captureVideoInUIProcessEnabled();
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKProtectionSpace.cpp b/Source/WebKit/UIProcess/API/C/WKProtectionSpace.cpp
>index 7e764b900e3fd64e845125a134d94f8c2b5cfc0c..d0a759bc6b06172487d309b1af93d78ec7b00d20 100644
>--- a/Source/WebKit/UIProcess/API/C/WKProtectionSpace.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKProtectionSpace.cpp
>@@ -38,35 +38,35 @@ WKTypeID WKProtectionSpaceGetTypeID()
> 
> WKStringRef WKProtectionSpaceCopyHost(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toCopiedAPI(toImpl(protectionSpaceRef)->host());
>+    return toCopiedAPI(WebKit::toImpl(protectionSpaceRef)->host());
> }
> 
> int WKProtectionSpaceGetPort(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toImpl(protectionSpaceRef)->port();
>+    return WebKit::toImpl(protectionSpaceRef)->port();
> }
> 
> WKStringRef WKProtectionSpaceCopyRealm(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toCopiedAPI(toImpl(protectionSpaceRef)->realm());
>+    return toCopiedAPI(WebKit::toImpl(protectionSpaceRef)->realm());
> }
> 
> bool WKProtectionSpaceGetIsProxy(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toImpl(protectionSpaceRef)->isProxy();
>+    return WebKit::toImpl(protectionSpaceRef)->isProxy();
> }
> 
> WKProtectionSpaceServerType WKProtectionSpaceGetServerType(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toAPI(toImpl(protectionSpaceRef)->serverType());
>+    return toAPI(WebKit::toImpl(protectionSpaceRef)->serverType());
> }
> 
> bool WKProtectionSpaceGetReceivesCredentialSecurely(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toImpl(protectionSpaceRef)->receivesCredentialSecurely();
>+    return WebKit::toImpl(protectionSpaceRef)->receivesCredentialSecurely();
> }
> 
> WKProtectionSpaceAuthenticationScheme WKProtectionSpaceGetAuthenticationScheme(WKProtectionSpaceRef protectionSpaceRef)
> {
>-    return toAPI(toImpl(protectionSpaceRef)->authenticationScheme());
>+    return toAPI(WebKit::toImpl(protectionSpaceRef)->authenticationScheme());
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKResourceCacheManager.cpp b/Source/WebKit/UIProcess/API/C/WKResourceCacheManager.cpp
>index 442fc8f86c40ad6ae9e65be443dd0496ab7d52cd..250df675b5ea8facfee549a4d6f73e49c8268539 100644
>--- a/Source/WebKit/UIProcess/API/C/WKResourceCacheManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKResourceCacheManager.cpp
>@@ -50,7 +50,7 @@ static OptionSet<WebsiteDataType> toWebsiteDataTypes(WKResourceCachesToClear cac
> 
> void WKResourceCacheManagerGetCacheOrigins(WKResourceCacheManagerRef cacheManager, void* context, WKResourceCacheManagerGetCacheOriginsFunction callback)
> {
>-    auto& websiteDataStore = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(cacheManager))->websiteDataStore();
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(cacheManager))->websiteDataStore();
>     websiteDataStore.fetchData(toWebsiteDataTypes(WKResourceCachesToClearAll), { }, [context, callback](auto dataRecords) {
>         Vector<RefPtr<API::Object>> securityOrigins;
>         for (const auto& dataRecord : dataRecords) {
>@@ -64,20 +64,20 @@ void WKResourceCacheManagerGetCacheOrigins(WKResourceCacheManagerRef cacheManage
> 
> void WKResourceCacheManagerClearCacheForOrigin(WKResourceCacheManagerRef cacheManager, WKSecurityOriginRef origin, WKResourceCachesToClear cachesToClear)
> {
>-    auto& websiteDataStore = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(cacheManager))->websiteDataStore();
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(cacheManager))->websiteDataStore();
> 
>     Vector<WebsiteDataRecord> dataRecords;
> 
>     {
>         WebsiteDataRecord dataRecord;
>-        dataRecord.add(WebsiteDataType::MemoryCache, toImpl(origin)->securityOrigin().data());
>+        dataRecord.add(WebsiteDataType::MemoryCache, WebKit::toImpl(origin)->securityOrigin().data());
> 
>         dataRecords.append(dataRecord);
>     }
> 
>     if (cachesToClear == WKResourceCachesToClearAll) {
>         WebsiteDataRecord dataRecord;
>-        dataRecord.add(WebsiteDataType::DiskCache, toImpl(origin)->securityOrigin().data());
>+        dataRecord.add(WebsiteDataType::DiskCache, WebKit::toImpl(origin)->securityOrigin().data());
> 
>         dataRecords.append(dataRecord);
>     }
>@@ -87,6 +87,6 @@ void WKResourceCacheManagerClearCacheForOrigin(WKResourceCacheManagerRef cacheMa
> 
> void WKResourceCacheManagerClearCacheForAllOrigins(WKResourceCacheManagerRef cacheManager, WKResourceCachesToClear cachesToClear)
> {
>-    auto& websiteDataStore = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(cacheManager))->websiteDataStore();
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(cacheManager))->websiteDataStore();
>     websiteDataStore.removeData(toWebsiteDataTypes(cachesToClear), -WallTime::infinity(), [] { });
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKTextChecker.cpp b/Source/WebKit/UIProcess/API/C/WKTextChecker.cpp
>index c8e7560b17561a25e42ba19c69ca6b0c4bc59be1..a3548ea9576ff46806d06e628f78b1c0ca844848 100644
>--- a/Source/WebKit/UIProcess/API/C/WKTextChecker.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKTextChecker.cpp
>@@ -61,12 +61,12 @@ void WKTextCheckerGrammarCheckingEnabledStateChanged(bool enabled)
> 
> void WKTextCheckerCheckSpelling(WKPageRef page, bool startBeforeSelection)
> {
>-    WebTextChecker::singleton()->checkSpelling(toImpl(page), startBeforeSelection);
>+    WebTextChecker::singleton()->checkSpelling(WebKit::toImpl(page), startBeforeSelection);
> }
> 
> void WKTextCheckerChangeSpellingToWord(WKPageRef page, WKStringRef word)
> {
>-    WebTextChecker::singleton()->changeSpellingToWord(toImpl(page), toWTFString(word));
>+    WebTextChecker::singleton()->changeSpellingToWord(WebKit::toImpl(page), toWTFString(word));
> }
> 
> #endif
>diff --git a/Source/WebKit/UIProcess/API/C/WKUserContentControllerRef.cpp b/Source/WebKit/UIProcess/API/C/WKUserContentControllerRef.cpp
>index f157c07c9a8f364a75b9b570faed29151da90c8a..47b79dc10ea418b23414755efb6d37cfa1d98904 100644
>--- a/Source/WebKit/UIProcess/API/C/WKUserContentControllerRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKUserContentControllerRef.cpp
>@@ -47,30 +47,30 @@ WKUserContentControllerRef WKUserContentControllerCreate()
> 
> WKArrayRef WKUserContentControllerCopyUserScripts(WKUserContentControllerRef userContentControllerRef)
> {
>-    Ref<API::Array> userScripts = toImpl(userContentControllerRef)->userScripts().copy();
>+    Ref<API::Array> userScripts = WebKit::toImpl(userContentControllerRef)->userScripts().copy();
>     return toAPI(&userScripts.leakRef());
> }
> 
> void WKUserContentControllerAddUserScript(WKUserContentControllerRef userContentControllerRef, WKUserScriptRef userScriptRef)
> {
>-    toImpl(userContentControllerRef)->addUserScript(*toImpl(userScriptRef), InjectUserScriptImmediately::No);
>+    WebKit::toImpl(userContentControllerRef)->addUserScript(*WebKit::toImpl(userScriptRef), InjectUserScriptImmediately::No);
> }
> 
> void WKUserContentControllerRemoveAllUserScripts(WKUserContentControllerRef userContentControllerRef)
> {
>-    toImpl(userContentControllerRef)->removeAllUserScripts();
>+    WebKit::toImpl(userContentControllerRef)->removeAllUserScripts();
> }
> 
> void WKUserContentControllerAddUserContentFilter(WKUserContentControllerRef userContentControllerRef, WKUserContentFilterRef userContentFilterRef)
> {
> #if ENABLE(CONTENT_EXTENSIONS)
>-    toImpl(userContentControllerRef)->addContentRuleList(*toImpl(userContentFilterRef));
>+    WebKit::toImpl(userContentControllerRef)->addContentRuleList(*WebKit::toImpl(userContentFilterRef));
> #endif
> }
> 
> void WKUserContentControllerRemoveAllUserContentFilters(WKUserContentControllerRef userContentControllerRef)
> {
> #if ENABLE(CONTENT_EXTENSIONS)
>-    toImpl(userContentControllerRef)->removeAllContentRuleLists();
>+    WebKit::toImpl(userContentControllerRef)->removeAllContentRuleLists();
> #endif
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionCheck.cpp b/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionCheck.cpp
>index 89cfeaae7ae4c049aae1d5cac7c1ca4007d04461..4c531611a2d3d3907b3172c0b18d5d0d1ad1d8c3 100644
>--- a/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionCheck.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionCheck.cpp
>@@ -42,6 +42,6 @@ WKTypeID WKUserMediaPermissionCheckGetTypeID()
> 
> void WKUserMediaPermissionCheckSetUserMediaAccessInfo(WKUserMediaPermissionCheckRef userMediaPermissionRequestRef, WKStringRef, bool allowed)
> {
>-    toImpl(userMediaPermissionRequestRef)->setUserMediaAccessInfo(allowed);
>+    WebKit::toImpl(userMediaPermissionRequestRef)->setUserMediaAccessInfo(allowed);
> }
> 
>diff --git a/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionRequest.cpp b/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionRequest.cpp
>index 453669512bfc59e07b47a70e0df06b8d19adf459..7d4c6d6d44e869a3fbeb07fd845810fbba7fa1dc 100644
>--- a/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionRequest.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKUserMediaPermissionRequest.cpp
>@@ -36,7 +36,7 @@ WKTypeID WKUserMediaPermissionRequestGetTypeID()
> 
> void WKUserMediaPermissionRequestAllow(WKUserMediaPermissionRequestRef userMediaPermissionRequestRef, WKStringRef audioDeviceUID, WKStringRef videoDeviceUID)
> {
>-    toImpl(userMediaPermissionRequestRef)->allow(toWTFString(audioDeviceUID), toWTFString(videoDeviceUID));
>+    WebKit::toImpl(userMediaPermissionRequestRef)->allow(toWTFString(audioDeviceUID), toWTFString(videoDeviceUID));
> }
> 
> static UserMediaPermissionRequestProxy::UserMediaAccessDenialReason toWK(UserMediaPermissionRequestDenialReason reason)
>@@ -72,14 +72,14 @@ static UserMediaPermissionRequestProxy::UserMediaAccessDenialReason toWK(UserMed
> 
> void WKUserMediaPermissionRequestDeny(WKUserMediaPermissionRequestRef userMediaPermissionRequestRef, UserMediaPermissionRequestDenialReason reason)
> {
>-    toImpl(userMediaPermissionRequestRef)->deny(toWK(reason));
>+    WebKit::toImpl(userMediaPermissionRequestRef)->deny(toWK(reason));
> }
> 
> WKArrayRef WKUserMediaPermissionRequestVideoDeviceUIDs(WKUserMediaPermissionRequestRef userMediaPermissionRef)
> {
>     WKMutableArrayRef array = WKMutableArrayCreate();
> #if ENABLE(MEDIA_STREAM)
>-    for (auto& deviceUID : toImpl(userMediaPermissionRef)->videoDeviceUIDs())
>+    for (auto& deviceUID : WebKit::toImpl(userMediaPermissionRef)->videoDeviceUIDs())
>         WKArrayAppendItem(array, toAPI(API::String::create(deviceUID).ptr()));
> #endif
>     return array;
>@@ -89,7 +89,7 @@ WKArrayRef WKUserMediaPermissionRequestAudioDeviceUIDs(WKUserMediaPermissionRequ
> {
>     WKMutableArrayRef array = WKMutableArrayCreate();
> #if ENABLE(MEDIA_STREAM)
>-    for (auto& deviceUID : toImpl(userMediaPermissionRef)->audioDeviceUIDs())
>+    for (auto& deviceUID : WebKit::toImpl(userMediaPermissionRef)->audioDeviceUIDs())
>         WKArrayAppendItem(array, toAPI(API::String::create(deviceUID).ptr()));
> #endif
>     return array;
>diff --git a/Source/WebKit/UIProcess/API/C/WKUserScriptRef.cpp b/Source/WebKit/UIProcess/API/C/WKUserScriptRef.cpp
>index 17e762961de23f31910d4310745faaf2f32df1b8..23704661d47a361cf35428f53e2bac23110dd6f7 100644
>--- a/Source/WebKit/UIProcess/API/C/WKUserScriptRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKUserScriptRef.cpp
>@@ -43,15 +43,15 @@ WKUserScriptRef WKUserScriptCreateWithSource(WKStringRef sourceRef, _WKUserScrip
> 
> WKStringRef WKUserScriptCopySource(WKUserScriptRef userScriptRef)
> {
>-    return toCopiedAPI(toImpl(userScriptRef)->userScript().source());
>+    return toCopiedAPI(WebKit::toImpl(userScriptRef)->userScript().source());
> }
> 
> _WKUserScriptInjectionTime WKUserScriptGetInjectionTime(WKUserScriptRef userScriptRef)
> {
>-    return toWKUserScriptInjectionTime(toImpl(userScriptRef)->userScript().injectionTime());
>+    return toWKUserScriptInjectionTime(WebKit::toImpl(userScriptRef)->userScript().injectionTime());
> }
> 
> bool WKUserScriptGetMainFrameOnly(WKUserScriptRef userScriptRef)
> {
>-    return toImpl(userScriptRef)->userScript().injectedFrames() == WebCore::InjectInTopFrameOnly;
>+    return WebKit::toImpl(userScriptRef)->userScript().injectedFrames() == WebCore::InjectInTopFrameOnly;
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKWebsitePolicies.cpp b/Source/WebKit/UIProcess/API/C/WKWebsitePolicies.cpp
>index 668edb25d5f29d03ffbd3e1bd37b7fcad97ac9a9..a60039d6c79b769f316050a9925dfa8fbc75bc34 100644
>--- a/Source/WebKit/UIProcess/API/C/WKWebsitePolicies.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKWebsitePolicies.cpp
>@@ -48,18 +48,18 @@ WKWebsitePoliciesRef WKWebsitePoliciesCreate()
> 
> void WKWebsitePoliciesSetContentBlockersEnabled(WKWebsitePoliciesRef websitePolicies, bool enabled)
> {
>-    toImpl(websitePolicies)->setContentBlockersEnabled(enabled);
>+    WebKit::toImpl(websitePolicies)->setContentBlockersEnabled(enabled);
> }
> 
> bool WKWebsitePoliciesGetContentBlockersEnabled(WKWebsitePoliciesRef websitePolicies)
> {
>-    return toImpl(websitePolicies)->contentBlockersEnabled();
>+    return WebKit::toImpl(websitePolicies)->contentBlockersEnabled();
> }
> 
> WK_EXPORT WKDictionaryRef WKWebsitePoliciesCopyCustomHeaderFields(WKWebsitePoliciesRef websitePolicies)
> {
>     HashMap<WTF::String, RefPtr<API::Object>> fields;
>-    for (const auto& field : toImpl(websitePolicies)->customHeaderFields())
>+    for (const auto& field : WebKit::toImpl(websitePolicies)->customHeaderFields())
>         fields.add(field.name(), API::String::create(field.value()));
>     return toAPI(API::Dictionary::create(WTFMove(fields)).ptr());
> }
>@@ -72,11 +72,11 @@ WK_EXPORT void WKWebsitePoliciesSetCustomHeaderFields(WKWebsitePoliciesRef websi
>     fields.reserveInitialCapacity(length);
>     for (size_t i = 0; i < length; ++i) {
>         WKStringRef name = static_cast<WKStringRef>(WKArrayGetItemAtIndex(keys.get(), i));
>-        auto field = WebCore::HTTPHeaderField::create(toImpl(name)->string(), toImpl(static_cast<WKStringRef>(WKDictionaryGetItemForKey(dictionary, name)))->string());
>+        auto field = WebCore::HTTPHeaderField::create(WebKit::toImpl(name)->string(), WebKit::toImpl(static_cast<WKStringRef>(WKDictionaryGetItemForKey(dictionary, name)))->string());
>         if (field && startsWithLettersIgnoringASCIICase(field->name(), "x-"))
>             fields.uncheckedAppend(WTFMove(*field));
>     }
>-    toImpl(websitePolicies)->setCustomHeaderFields(WTFMove(fields));
>+    WebKit::toImpl(websitePolicies)->setCustomHeaderFields(WTFMove(fields));
> }
> 
> void WKWebsitePoliciesSetAllowedAutoplayQuirks(WKWebsitePoliciesRef websitePolicies, WKWebsiteAutoplayQuirk allowedQuirks)
>@@ -91,13 +91,13 @@ void WKWebsitePoliciesSetAllowedAutoplayQuirks(WKWebsitePoliciesRef websitePolic
>     if (allowedQuirks & kWKWebsiteAutoplayQuirkArbitraryUserGestures)
>         quirks.add(WebsiteAutoplayQuirk::ArbitraryUserGestures);
> 
>-    toImpl(websitePolicies)->setAllowedAutoplayQuirks(quirks);
>+    WebKit::toImpl(websitePolicies)->setAllowedAutoplayQuirks(quirks);
> }
> 
> WKWebsiteAutoplayQuirk WKWebsitePoliciesGetAllowedAutoplayQuirks(WKWebsitePoliciesRef websitePolicies)
> {
>     WKWebsiteAutoplayQuirk quirks = 0;
>-    auto allowedQuirks = toImpl(websitePolicies)->allowedAutoplayQuirks();
>+    auto allowedQuirks = WebKit::toImpl(websitePolicies)->allowedAutoplayQuirks();
> 
>     if (allowedQuirks.contains(WebsiteAutoplayQuirk::SynthesizedPauseEvents))
>         quirks |= kWKWebsiteAutoplayQuirkSynthesizedPauseEvents;
>@@ -113,7 +113,7 @@ WKWebsiteAutoplayQuirk WKWebsitePoliciesGetAllowedAutoplayQuirks(WKWebsitePolici
> 
> WKWebsiteAutoplayPolicy WKWebsitePoliciesGetAutoplayPolicy(WKWebsitePoliciesRef websitePolicies)
> {
>-    switch (toImpl(websitePolicies)->autoplayPolicy()) {
>+    switch (WebKit::toImpl(websitePolicies)->autoplayPolicy()) {
>     case WebKit::WebsiteAutoplayPolicy::Default:
>         return kWKWebsiteAutoplayPolicyDefault;
>     case WebsiteAutoplayPolicy::Allow:
>@@ -131,16 +131,16 @@ void WKWebsitePoliciesSetAutoplayPolicy(WKWebsitePoliciesRef websitePolicies, WK
> {
>     switch (policy) {
>     case kWKWebsiteAutoplayPolicyDefault:
>-        toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::Default);
>+        WebKit::toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::Default);
>         return;
>     case kWKWebsiteAutoplayPolicyAllow:
>-        toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::Allow);
>+        WebKit::toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::Allow);
>         return;
>     case kWKWebsiteAutoplayPolicyAllowWithoutSound:
>-        toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::AllowWithoutSound);
>+        WebKit::toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::AllowWithoutSound);
>         return;
>     case kWKWebsiteAutoplayPolicyDeny:
>-        toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::Deny);
>+        WebKit::toImpl(websitePolicies)->setAutoplayPolicy(WebsiteAutoplayPolicy::Deny);
>         return;
>     }
>     ASSERT_NOT_REACHED();
>@@ -148,7 +148,7 @@ void WKWebsitePoliciesSetAutoplayPolicy(WKWebsitePoliciesRef websitePolicies, WK
> 
> WKWebsitePopUpPolicy WKWebsitePoliciesGetPopUpPolicy(WKWebsitePoliciesRef websitePolicies)
> {
>-    switch (toImpl(websitePolicies)->popUpPolicy()) {
>+    switch (WebKit::toImpl(websitePolicies)->popUpPolicy()) {
>     case WebsitePopUpPolicy::Default:
>         return kWKWebsitePopUpPolicyDefault;
>     case WebsitePopUpPolicy::Allow:
>@@ -164,13 +164,13 @@ void WKWebsitePoliciesSetPopUpPolicy(WKWebsitePoliciesRef websitePolicies, WKWeb
> {
>     switch (policy) {
>     case kWKWebsitePopUpPolicyDefault:
>-        toImpl(websitePolicies)->setPopUpPolicy(WebsitePopUpPolicy::Default);
>+        WebKit::toImpl(websitePolicies)->setPopUpPolicy(WebsitePopUpPolicy::Default);
>         return;
>     case kWKWebsitePopUpPolicyAllow:
>-        toImpl(websitePolicies)->setPopUpPolicy(WebsitePopUpPolicy::Allow);
>+        WebKit::toImpl(websitePolicies)->setPopUpPolicy(WebsitePopUpPolicy::Allow);
>         return;
>     case kWKWebsitePopUpPolicyBlock:
>-        toImpl(websitePolicies)->setPopUpPolicy(WebsitePopUpPolicy::Block);
>+        WebKit::toImpl(websitePolicies)->setPopUpPolicy(WebsitePopUpPolicy::Block);
>         return;
>     }
>     ASSERT_NOT_REACHED();
>@@ -178,11 +178,11 @@ void WKWebsitePoliciesSetPopUpPolicy(WKWebsitePoliciesRef websitePolicies, WKWeb
> 
> WKWebsiteDataStoreRef WKWebsitePoliciesGetDataStore(WKWebsitePoliciesRef websitePolicies)
> {
>-    return toAPI(toImpl(websitePolicies)->websiteDataStore());
>+    return toAPI(WebKit::toImpl(websitePolicies)->websiteDataStore());
> }
> 
> void WKWebsitePoliciesSetDataStore(WKWebsitePoliciesRef websitePolicies, WKWebsiteDataStoreRef websiteDataStore)
> {
>-    toImpl(websitePolicies)->setWebsiteDataStore(toImpl(websiteDataStore));
>+    WebKit::toImpl(websitePolicies)->setWebsiteDataStore(WebKit::toImpl(websiteDataStore));
> }
>

Actions: View | Formatted Diff | Diff

Attachments on bug 192450: 356704