362e1854fb84da26405468e378cedf9eee34d08f
[WebKit-https.git] / Source / WebKit2 / UIProcess / API / C / WKAPICast.h
1 /*
2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
3  * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef WKAPICast_h
28 #define WKAPICast_h
29
30 #include "CacheModel.h"
31 #include "FontSmoothingLevel.h"
32 #include "HTTPCookieAcceptPolicy.h"
33 #include "InjectedBundleHitTestResultMediaType.h"
34 #include "PluginModuleInfo.h"
35 #include "ProcessModel.h"
36 #include "ResourceCachesToClear.h"
37 #include "WKBundleHitTestResult.h"
38 #include "WKContext.h"
39 #include "WKCookieManager.h"
40 #include "WKCredentialTypes.h"
41 #include "WKPage.h"
42 #include "WKPreferences.h"
43 #include "WKPreferencesPrivate.h"
44 #include "WKProtectionSpaceTypes.h"
45 #include "WKResourceCacheManager.h"
46 #include "WKSharedAPICast.h"
47 #include "WebGrammarDetail.h"
48 #include <WebCore/Credential.h>
49 #include <WebCore/FrameLoaderTypes.h>
50 #include <WebCore/ProtectionSpace.h>
51 #include <WebCore/Settings.h>
52
53 namespace API {
54 class NavigationData;
55 }
56
57 namespace WebKit {
58
59 class AuthenticationChallengeProxy;
60 class AuthenticationDecisionListener;
61 class DownloadProxy;
62 class GeolocationPermissionRequestProxy;
63 class NotificationPermissionRequest;
64 class WebApplicationCacheManagerProxy;
65 class WebBackForwardList;
66 class WebBackForwardListItem;
67 class WebBatteryManagerProxy;
68 class WebBatteryStatus;
69 class WebResourceCacheManagerProxy;
70 class WebColorPickerResultListenerProxy;
71 class WebContext;
72 class WebCookieManagerProxy;
73 class WebCredential;
74 class WebDatabaseManagerProxy;
75 class WebFormSubmissionListenerProxy;
76 class WebFramePolicyListenerProxy;
77 class WebFrameProxy;
78 class WebGeolocationManagerProxy;
79 class WebGeolocationPosition;
80 class WebGrammarDetail;
81 class WebHitTestResult;
82 class WebIconDatabase;
83 class WebInspectorProxy;
84 class WebKeyValueStorageManager;
85 class WebMediaCacheManagerProxy;
86 class WebNetworkInfoManagerProxy;
87 class WebNetworkInfo;
88 class WebNotification;
89 class WebNotificationProvider;
90 class WebNotificationManagerProxy;
91 class WebOpenPanelParameters;
92 class WebOpenPanelResultListenerProxy;
93 class WebOriginDataManagerProxy;
94 class WebPageGroup;
95 class WebPageProxy;
96 class WebPluginSiteDataManager;
97 class WebPreferences;
98 class WebProtectionSpace;
99 class WebRenderLayer;
100 class WebRenderObject;
101 class WebTextChecker;
102 class WebVibrationProxy;
103 class WebViewportAttributes;
104
105 WK_ADD_API_MAPPING(WKApplicationCacheManagerRef, WebApplicationCacheManagerProxy)
106 WK_ADD_API_MAPPING(WKAuthenticationChallengeRef, AuthenticationChallengeProxy)
107 WK_ADD_API_MAPPING(WKAuthenticationDecisionListenerRef, AuthenticationDecisionListener)
108 WK_ADD_API_MAPPING(WKBackForwardListItemRef, WebBackForwardListItem)
109 WK_ADD_API_MAPPING(WKBackForwardListRef, WebBackForwardList)
110 WK_ADD_API_MAPPING(WKBatteryManagerRef, WebBatteryManagerProxy)
111 WK_ADD_API_MAPPING(WKBatteryStatusRef, WebBatteryStatus)
112 WK_ADD_API_MAPPING(WKBundleHitTestResultMediaType, BundleHitTestResultMediaType)
113 WK_ADD_API_MAPPING(WKResourceCacheManagerRef, WebResourceCacheManagerProxy)
114 WK_ADD_API_MAPPING(WKColorPickerResultListenerRef, WebColorPickerResultListenerProxy)
115 WK_ADD_API_MAPPING(WKContextRef, WebContext)
116 WK_ADD_API_MAPPING(WKCookieManagerRef, WebCookieManagerProxy)
117 WK_ADD_API_MAPPING(WKCredentialRef, WebCredential)
118 WK_ADD_API_MAPPING(WKDatabaseManagerRef, WebDatabaseManagerProxy)
119 WK_ADD_API_MAPPING(WKDownloadRef, DownloadProxy)
120 WK_ADD_API_MAPPING(WKFormSubmissionListenerRef, WebFormSubmissionListenerProxy)
121 WK_ADD_API_MAPPING(WKFramePolicyListenerRef, WebFramePolicyListenerProxy)
122 WK_ADD_API_MAPPING(WKFrameRef, WebFrameProxy)
123 WK_ADD_API_MAPPING(WKGeolocationManagerRef, WebGeolocationManagerProxy)
124 WK_ADD_API_MAPPING(WKGeolocationPermissionRequestRef, GeolocationPermissionRequestProxy)
125 WK_ADD_API_MAPPING(WKGeolocationPositionRef, WebGeolocationPosition)
126 WK_ADD_API_MAPPING(WKGrammarDetailRef, WebGrammarDetail)
127 WK_ADD_API_MAPPING(WKHitTestResultRef, WebHitTestResult)
128 WK_ADD_API_MAPPING(WKIconDatabaseRef, WebIconDatabase)
129 WK_ADD_API_MAPPING(WKKeyValueStorageManagerRef, WebKeyValueStorageManager)
130 WK_ADD_API_MAPPING(WKMediaCacheManagerRef, WebMediaCacheManagerProxy)
131 WK_ADD_API_MAPPING(WKNavigationDataRef, API::NavigationData)
132 WK_ADD_API_MAPPING(WKNetworkInfoManagerRef, WebNetworkInfoManagerProxy)
133 WK_ADD_API_MAPPING(WKNetworkInfoRef, WebNetworkInfo)
134 WK_ADD_API_MAPPING(WKNotificationManagerRef, WebNotificationManagerProxy)
135 WK_ADD_API_MAPPING(WKNotificationPermissionRequestRef, NotificationPermissionRequest)
136 WK_ADD_API_MAPPING(WKNotificationProviderRef, WebNotificationProvider)
137 WK_ADD_API_MAPPING(WKNotificationRef, WebNotification)
138 WK_ADD_API_MAPPING(WKOpenPanelParametersRef, WebOpenPanelParameters)
139 WK_ADD_API_MAPPING(WKOpenPanelResultListenerRef, WebOpenPanelResultListenerProxy)
140 WK_ADD_API_MAPPING(WKOriginDataManagerRef, WebOriginDataManagerProxy)
141 WK_ADD_API_MAPPING(WKPageGroupRef, WebPageGroup)
142 WK_ADD_API_MAPPING(WKPageRef, WebPageProxy)
143 WK_ADD_API_MAPPING(WKPluginSiteDataManagerRef, WebPluginSiteDataManager)
144 WK_ADD_API_MAPPING(WKPreferencesRef, WebPreferences)
145 WK_ADD_API_MAPPING(WKProtectionSpaceRef, WebProtectionSpace)
146 WK_ADD_API_MAPPING(WKRenderLayerRef, WebRenderLayer)
147 WK_ADD_API_MAPPING(WKRenderObjectRef, WebRenderObject)
148 WK_ADD_API_MAPPING(WKTextCheckerRef, WebTextChecker)
149 WK_ADD_API_MAPPING(WKVibrationRef, WebVibrationProxy)
150 WK_ADD_API_MAPPING(WKViewportAttributesRef, WebViewportAttributes)
151 WK_ADD_API_MAPPING(WKInspectorRef, WebInspectorProxy)
152
153 /* Enum conversions */
154
155 inline BundleHitTestResultMediaType toBundleHitTestResultMediaType(WKBundleHitTestResultMediaType wkMediaType)
156 {
157     switch (wkMediaType) {
158     case kWKBundleHitTestResultMediaTypeNone:
159         return BundleHitTestResultMediaTypeNone;
160     case kWKBundleHitTestResultMediaTypeAudio:
161         return BundleHitTestResultMediaTypeAudio;
162     case kWKBundleHitTestResultMediaTypeVideo:
163         return BundleHitTestResultMediaTypeVideo;
164     }
165     
166     ASSERT_NOT_REACHED();
167     return BundleHitTestResultMediaTypeNone;
168 }
169     
170 inline WKBundleHitTestResultMediaType toAPI(BundleHitTestResultMediaType mediaType)
171 {
172     switch (mediaType) {
173     case BundleHitTestResultMediaTypeNone:
174         return kWKBundleHitTestResultMediaTypeNone;
175     case BundleHitTestResultMediaTypeAudio:
176         return kWKBundleHitTestResultMediaTypeAudio;
177     case BundleHitTestResultMediaTypeVideo:
178         return kWKBundleHitTestResultMediaTypeVideo;
179     }
180     
181     ASSERT_NOT_REACHED();
182     return kWKBundleHitTestResultMediaTypeNone;
183 }
184
185 inline CacheModel toCacheModel(WKCacheModel wkCacheModel)
186 {
187     switch (wkCacheModel) {
188     case kWKCacheModelDocumentViewer:
189         return CacheModelDocumentViewer;
190     case kWKCacheModelDocumentBrowser:
191         return CacheModelDocumentBrowser;
192     case kWKCacheModelPrimaryWebBrowser:
193         return CacheModelPrimaryWebBrowser;
194     }
195
196     ASSERT_NOT_REACHED();
197     return CacheModelDocumentViewer;
198 }
199
200 inline WKCacheModel toAPI(CacheModel cacheModel)
201 {
202     switch (cacheModel) {
203     case CacheModelDocumentViewer:
204         return kWKCacheModelDocumentViewer;
205     case CacheModelDocumentBrowser:
206         return kWKCacheModelDocumentBrowser;
207     case CacheModelPrimaryWebBrowser:
208         return kWKCacheModelPrimaryWebBrowser;
209     }
210     
211     return kWKCacheModelDocumentViewer;
212 }
213
214 inline ProcessModel toProcessModel(WKProcessModel wkProcessModel)
215 {
216     switch (wkProcessModel) {
217     case kWKProcessModelSharedSecondaryProcess:
218         return ProcessModelSharedSecondaryProcess;
219     case kWKProcessModelMultipleSecondaryProcesses:
220         return ProcessModelMultipleSecondaryProcesses;
221     }
222
223     ASSERT_NOT_REACHED();
224     return ProcessModelSharedSecondaryProcess;
225 }
226
227 inline WKProcessModel toAPI(ProcessModel processModel)
228 {
229     switch (processModel) {
230     case ProcessModelSharedSecondaryProcess:
231         return kWKProcessModelSharedSecondaryProcess;
232     case ProcessModelMultipleSecondaryProcesses:
233         return kWKProcessModelMultipleSecondaryProcesses;
234     }
235     
236     return kWKProcessModelSharedSecondaryProcess;
237 }
238
239 inline FontSmoothingLevel toFontSmoothingLevel(WKFontSmoothingLevel wkLevel)
240 {
241     switch (wkLevel) {
242     case kWKFontSmoothingLevelNoSubpixelAntiAliasing:
243         return FontSmoothingLevelNoSubpixelAntiAliasing;
244     case kWKFontSmoothingLevelLight:
245         return FontSmoothingLevelLight;
246     case kWKFontSmoothingLevelMedium:
247         return FontSmoothingLevelMedium;
248     case kWKFontSmoothingLevelStrong:
249         return FontSmoothingLevelStrong;
250     }
251
252     ASSERT_NOT_REACHED();
253     return FontSmoothingLevelMedium;
254 }
255
256
257 inline WKFontSmoothingLevel toAPI(FontSmoothingLevel level)
258 {
259     switch (level) {
260     case FontSmoothingLevelNoSubpixelAntiAliasing:
261         return kWKFontSmoothingLevelNoSubpixelAntiAliasing;
262     case FontSmoothingLevelLight:
263         return kWKFontSmoothingLevelLight;
264     case FontSmoothingLevelMedium:
265         return kWKFontSmoothingLevelMedium;
266     case FontSmoothingLevelStrong:
267         return kWKFontSmoothingLevelStrong;
268     }
269
270     ASSERT_NOT_REACHED();
271     return kWKFontSmoothingLevelMedium;
272 }
273
274 inline WKEditableLinkBehavior toAPI(WebCore::EditableLinkBehavior behavior)
275 {
276     switch (behavior) {
277     case WebCore::EditableLinkDefaultBehavior:
278         return kWKEditableLinkBehaviorDefault;
279     case WebCore::EditableLinkAlwaysLive:
280         return kWKEditableLinkBehaviorAlwaysLive;
281     case WebCore::EditableLinkOnlyLiveWithShiftKey:
282         return kWKEditableLinkBehaviorOnlyLiveWithShiftKey;
283     case WebCore::EditableLinkLiveWhenNotFocused:
284         return kWKEditableLinkBehaviorLiveWhenNotFocused;
285     case WebCore::EditableLinkNeverLive:
286         return kWKEditableLinkBehaviorNeverLive;
287     }
288     
289     ASSERT_NOT_REACHED();
290     return kWKEditableLinkBehaviorNeverLive;
291 }
292
293 inline WebCore::EditableLinkBehavior toEditableLinkBehavior(WKEditableLinkBehavior wkBehavior)
294 {
295     switch (wkBehavior) {
296     case kWKEditableLinkBehaviorDefault:
297         return WebCore::EditableLinkDefaultBehavior;
298     case kWKEditableLinkBehaviorAlwaysLive:
299         return WebCore::EditableLinkAlwaysLive;
300     case kWKEditableLinkBehaviorOnlyLiveWithShiftKey:
301         return WebCore::EditableLinkOnlyLiveWithShiftKey;
302     case kWKEditableLinkBehaviorLiveWhenNotFocused:
303         return WebCore::EditableLinkLiveWhenNotFocused;
304     case kWKEditableLinkBehaviorNeverLive:
305         return WebCore::EditableLinkNeverLive;
306     }
307     
308     ASSERT_NOT_REACHED();
309     return WebCore::EditableLinkNeverLive;
310 }
311     
312 inline WKProtectionSpaceServerType toAPI(WebCore::ProtectionSpaceServerType type)
313 {
314     switch (type) {
315     case WebCore::ProtectionSpaceServerHTTP:
316         return kWKProtectionSpaceServerTypeHTTP;
317     case WebCore::ProtectionSpaceServerHTTPS:
318         return kWKProtectionSpaceServerTypeHTTPS;
319     case WebCore::ProtectionSpaceServerFTP:
320         return kWKProtectionSpaceServerTypeFTP;
321     case WebCore::ProtectionSpaceServerFTPS:
322         return kWKProtectionSpaceServerTypeFTPS;
323     case WebCore::ProtectionSpaceProxyHTTP:
324         return kWKProtectionSpaceProxyTypeHTTP;
325     case WebCore::ProtectionSpaceProxyHTTPS:
326         return kWKProtectionSpaceProxyTypeHTTPS;
327     case WebCore::ProtectionSpaceProxyFTP:
328         return kWKProtectionSpaceProxyTypeFTP;
329     case WebCore::ProtectionSpaceProxySOCKS:
330         return kWKProtectionSpaceProxyTypeSOCKS;
331     }
332     return kWKProtectionSpaceServerTypeHTTP;
333 }
334
335 inline WKProtectionSpaceAuthenticationScheme toAPI(WebCore::ProtectionSpaceAuthenticationScheme type)
336 {
337     switch (type) {
338     case WebCore::ProtectionSpaceAuthenticationSchemeDefault:
339         return kWKProtectionSpaceAuthenticationSchemeDefault;
340     case WebCore::ProtectionSpaceAuthenticationSchemeHTTPBasic:
341         return kWKProtectionSpaceAuthenticationSchemeHTTPBasic;
342     case WebCore::ProtectionSpaceAuthenticationSchemeHTTPDigest:
343         return kWKProtectionSpaceAuthenticationSchemeHTTPDigest;
344     case WebCore::ProtectionSpaceAuthenticationSchemeHTMLForm:
345         return kWKProtectionSpaceAuthenticationSchemeHTMLForm;
346     case WebCore::ProtectionSpaceAuthenticationSchemeNTLM:
347         return kWKProtectionSpaceAuthenticationSchemeNTLM;
348     case WebCore::ProtectionSpaceAuthenticationSchemeNegotiate:
349         return kWKProtectionSpaceAuthenticationSchemeNegotiate;
350     case WebCore::ProtectionSpaceAuthenticationSchemeClientCertificateRequested:
351         return kWKProtectionSpaceAuthenticationSchemeClientCertificateRequested;
352     case WebCore::ProtectionSpaceAuthenticationSchemeServerTrustEvaluationRequested:
353         return kWKProtectionSpaceAuthenticationSchemeServerTrustEvaluationRequested;
354     default:
355         return kWKProtectionSpaceAuthenticationSchemeUnknown;
356     }
357 }
358
359 inline WebCore::CredentialPersistence toCredentialPersistence(WKCredentialPersistence type)
360 {
361     switch (type) {
362     case kWKCredentialPersistenceNone:
363         return WebCore::CredentialPersistenceNone;
364     case kWKCredentialPersistenceForSession:
365         return WebCore::CredentialPersistenceForSession;
366     case kWKCredentialPersistencePermanent:
367         return WebCore::CredentialPersistencePermanent;
368     default:
369         return WebCore::CredentialPersistenceNone;
370     }
371 }
372
373 inline ResourceCachesToClear toResourceCachesToClear(WKResourceCachesToClear wkResourceCachesToClear)
374 {
375     switch (wkResourceCachesToClear) {
376     case WKResourceCachesToClearAll:
377         return AllResourceCaches;
378     case WKResourceCachesToClearInMemoryOnly:
379         return InMemoryResourceCachesOnly;
380     }
381
382     ASSERT_NOT_REACHED();
383     return AllResourceCaches;
384 }
385
386 inline HTTPCookieAcceptPolicy toHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy)
387 {
388     switch (policy) {
389     case kWKHTTPCookieAcceptPolicyAlways:
390         return HTTPCookieAcceptPolicyAlways;
391     case kWKHTTPCookieAcceptPolicyNever:
392         return HTTPCookieAcceptPolicyNever;
393     case kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
394         return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
395     }
396
397     ASSERT_NOT_REACHED();
398     return HTTPCookieAcceptPolicyAlways;
399 }
400
401 inline WKHTTPCookieAcceptPolicy toAPI(HTTPCookieAcceptPolicy policy)
402 {
403     switch (policy) {
404     case HTTPCookieAcceptPolicyAlways:
405         return kWKHTTPCookieAcceptPolicyAlways;
406     case HTTPCookieAcceptPolicyNever:
407         return kWKHTTPCookieAcceptPolicyNever;
408     case HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
409         return kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
410     }
411
412     ASSERT_NOT_REACHED();
413     return kWKHTTPCookieAcceptPolicyAlways;
414 }
415
416 inline WebCore::SecurityOrigin::StorageBlockingPolicy toStorageBlockingPolicy(WKStorageBlockingPolicy policy)
417 {
418     switch (policy) {
419     case kWKAllowAllStorage:
420         return WebCore::SecurityOrigin::AllowAllStorage;
421     case kWKBlockThirdPartyStorage:
422         return WebCore::SecurityOrigin::BlockThirdPartyStorage;
423     case kWKBlockAllStorage:
424         return WebCore::SecurityOrigin::BlockAllStorage;
425     }
426
427     ASSERT_NOT_REACHED();
428     return WebCore::SecurityOrigin::AllowAllStorage;
429 }
430
431 inline WKStorageBlockingPolicy toAPI(WebCore::SecurityOrigin::StorageBlockingPolicy policy)
432 {
433     switch (policy) {
434     case WebCore::SecurityOrigin::AllowAllStorage:
435         return kWKAllowAllStorage;
436     case WebCore::SecurityOrigin::BlockThirdPartyStorage:
437         return kWKBlockThirdPartyStorage;
438     case WebCore::SecurityOrigin::BlockAllStorage:
439         return kWKBlockAllStorage;
440     }
441
442     ASSERT_NOT_REACHED();
443     return kWKAllowAllStorage;
444 }
445
446 inline WKPluginLoadPolicy toWKPluginLoadPolicy(PluginModuleLoadPolicy pluginModuleLoadPolicy)
447 {
448     switch (pluginModuleLoadPolicy) {
449     case PluginModuleLoadNormally:
450         return kWKPluginLoadPolicyLoadNormally;
451     case PluginModuleLoadUnsandboxed:
452         return kWKPluginLoadPolicyLoadUnsandboxed;
453     case PluginModuleBlocked:
454         return kWKPluginLoadPolicyBlocked;
455     }
456     
457     ASSERT_NOT_REACHED();
458     return kWKPluginLoadPolicyBlocked;
459 }
460
461 inline PluginModuleLoadPolicy toPluginModuleLoadPolicy(WKPluginLoadPolicy pluginLoadPolicy)
462 {
463     switch (pluginLoadPolicy) {
464     case kWKPluginLoadPolicyLoadNormally:
465         return PluginModuleLoadNormally;
466     case kWKPluginLoadPolicyBlocked:
467         return PluginModuleBlocked;
468     case kWKPluginLoadPolicyLoadUnsandboxed:
469         return PluginModuleLoadUnsandboxed;
470     }
471     
472     ASSERT_NOT_REACHED();
473     return PluginModuleBlocked;
474 }
475
476 inline WebCore::WebGLLoadPolicy toWebGLLoadPolicy(WKWebGLLoadPolicy webGLLoadPolicy)
477 {
478     switch (webGLLoadPolicy) {
479     case kWKWebGLLoadPolicyInactive:
480         return WebCore::WebGLAsk;
481     case kWKWebGLLoadPolicyLoadNormally:
482         return WebCore::WebGLAllow;
483     case kWKWebGLLoadPolicyBlocked:
484         return WebCore::WebGLBlock;
485     }
486     
487     ASSERT_NOT_REACHED();
488     return WebCore::WebGLAllow;
489 }
490
491 inline ProxyingRefPtr<WebGrammarDetail> toAPI(const WebCore::GrammarDetail& grammarDetail)
492 {
493     return ProxyingRefPtr<WebGrammarDetail>(WebGrammarDetail::create(grammarDetail));
494 }
495
496 } // namespace WebKit
497
498 #if defined(BUILDING_GTK__)
499 #include "WKAPICastGtk.h"
500 #endif
501
502 #if USE(SOUP)
503 #include "WKAPICastSoup.h"
504 #endif
505
506 #if defined(BUILDING_EFL__)
507 #include "WKAPICastEfl.h"
508 #endif
509
510 #endif // WKAPICast_h