Add URLRequest API for WebKit2
[WebKit-https.git] / WebKit2 / UIProcess / API / C / WKAPICast.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef WKAPICast_h
27 #define WKAPICast_h
28
29 #include "WKBase.h"
30 #include "WKPage.h"
31 #include "WebEvent.h"
32 #include "WebString.h"
33 #include "WebURL.h"
34 #include <WebCore/FrameLoaderTypes.h>
35
36 #if defined(WIN32) || defined(_WIN32)
37 #include "WKAPICastWin.h"
38 #endif
39
40 namespace WebKit {
41
42 class ImmutableArray;
43 class ImmutableDictionary;
44 class WebBackForwardList;
45 class WebBackForwardListItem;
46 class WebContext;
47 class WebData;
48 class WebError;
49 class WebFormSubmissionListenerProxy;
50 class WebFramePolicyListenerProxy;
51 class WebFrameProxy;
52 class WebNavigationData;
53 class WebPageNamespace;
54 class WebPageProxy;
55 class WebPreferences;
56 class WebURLRequest;
57 class WebURLResponse;
58
59 template<typename APIType> struct APITypeInfo { };
60 template<> struct APITypeInfo<WKTypeRef>                        { typedef APIObject* ImplType; };
61 template<> struct APITypeInfo<WKArrayRef>                       { typedef ImmutableArray* ImplType; };
62 template<> struct APITypeInfo<WKBackForwardListItemRef>         { typedef WebBackForwardListItem* ImplType; };
63 template<> struct APITypeInfo<WKBackForwardListRef>             { typedef WebBackForwardList* ImplType; };
64 template<> struct APITypeInfo<WKContextRef>                     { typedef WebContext* ImplType; };
65 template<> struct APITypeInfo<WKDataRef>                        { typedef WebData* ImplType; };
66 template<> struct APITypeInfo<WKDictionaryRef>                  { typedef ImmutableDictionary* ImplType; };
67 template<> struct APITypeInfo<WKFormSubmissionListenerRef>      { typedef WebFormSubmissionListenerProxy* ImplType; };
68 template<> struct APITypeInfo<WKFramePolicyListenerRef>         { typedef WebFramePolicyListenerProxy* ImplType; };
69 template<> struct APITypeInfo<WKFrameRef>                       { typedef WebFrameProxy* ImplType; };
70 template<> struct APITypeInfo<WKNavigationDataRef>              { typedef WebNavigationData* ImplType; };
71 template<> struct APITypeInfo<WKPageNamespaceRef>               { typedef WebPageNamespace* ImplType; };
72 template<> struct APITypeInfo<WKPageRef>                        { typedef WebPageProxy* ImplType; };
73 template<> struct APITypeInfo<WKPreferencesRef>                 { typedef WebPreferences* ImplType; };
74 template<> struct APITypeInfo<WKStringRef>                      { typedef WebString* ImplType; };
75 template<> struct APITypeInfo<WKURLRef>                         { typedef WebURL* ImplType; };
76 template<> struct APITypeInfo<WKURLRequestRef>                  { typedef WebURLRequest* ImplType; };
77 template<> struct APITypeInfo<WKURLResponseRef>                 { typedef WebURLResponse* ImplType; };
78
79
80 template<typename ImplType> struct ImplTypeInfo { };
81 template<> struct ImplTypeInfo<APIObject*>                      { typedef WKTypeRef APIType; };
82 template<> struct ImplTypeInfo<ImmutableArray*>                 { typedef WKArrayRef APIType; };
83 template<> struct ImplTypeInfo<ImmutableDictionary*>            { typedef WKDictionaryRef APIType; };
84 template<> struct ImplTypeInfo<WebBackForwardList*>             { typedef WKBackForwardListRef APIType; };
85 template<> struct ImplTypeInfo<WebBackForwardListItem*>         { typedef WKBackForwardListItemRef APIType; };
86 template<> struct ImplTypeInfo<WebContext*>                     { typedef WKContextRef APIType; };
87 template<> struct ImplTypeInfo<WebData*>                        { typedef WKDataRef APIType; };
88 template<> struct ImplTypeInfo<WebError*>                       { typedef WKErrorRef APIType; };
89 template<> struct ImplTypeInfo<WebFormSubmissionListenerProxy*> { typedef WKFormSubmissionListenerRef APIType; };
90 template<> struct ImplTypeInfo<WebFramePolicyListenerProxy*>    { typedef WKFramePolicyListenerRef APIType; };
91 template<> struct ImplTypeInfo<WebFrameProxy*>                  { typedef WKFrameRef APIType; };
92 template<> struct ImplTypeInfo<WebNavigationData*>              { typedef WKNavigationDataRef APIType; };
93 template<> struct ImplTypeInfo<WebPageNamespace*>               { typedef WKPageNamespaceRef APIType; };
94 template<> struct ImplTypeInfo<WebPageProxy*>                   { typedef WKPageRef APIType; };
95 template<> struct ImplTypeInfo<WebPreferences*>                 { typedef WKPreferencesRef APIType; };
96 template<> struct ImplTypeInfo<WebString*>                      { typedef WKStringRef APIType; };
97 template<> struct ImplTypeInfo<WebURL*>                         { typedef WKURLRef APIType; };
98 template<> struct ImplTypeInfo<WebURLRequest*>                  { typedef WKURLRequestRef APIType; };
99 template<> struct ImplTypeInfo<WebURLResponse*>                 { typedef WKURLResponseRef APIType; };
100
101
102 template<typename ImplType, typename APIType = typename ImplTypeInfo<ImplType*>::APIType>
103 class ProxyingRefPtr {
104 public:
105     ProxyingRefPtr(PassRefPtr<ImplType> impl)
106         : m_impl(impl)
107     {
108     }
109
110     operator APIType() { return toRef(m_impl.get()); }
111
112 private:
113     RefPtr<ImplType> m_impl;
114 };
115
116 } // namespace WebKit
117
118 /* Opaque typing convenience methods */
119
120 template<typename T>
121 inline typename WebKit::APITypeInfo<T>::ImplType toWK(T t)
122 {
123     return reinterpret_cast<typename WebKit::APITypeInfo<T>::ImplType>(t);
124 }
125
126 template<typename T>
127 inline typename WebKit::ImplTypeInfo<T>::APIType toRef(T t)
128 {
129     return reinterpret_cast<typename WebKit::ImplTypeInfo<T>::APIType>(t);
130 }
131
132 /* Special cases. */
133
134 inline WebKit::ProxyingRefPtr<WebKit::WebString> toRef(WTF::StringImpl* string)
135 {
136     WTF::StringImpl* impl = string ? string : WTF::StringImpl::empty();
137     return WebKit::ProxyingRefPtr<WebKit::WebString>(WebKit::WebString::create(WTF::String(impl)));
138 }
139
140 inline WebKit::ProxyingRefPtr<WebKit::WebURL> toURLRef(WTF::StringImpl* string)
141 {
142     WTF::StringImpl* impl = string ? string : WTF::StringImpl::empty();
143     return WebKit::ProxyingRefPtr<WebKit::WebURL>(WebKit::WebURL::create(WTF::String(impl)));
144 }
145
146 inline WKStringRef toCopiedRef(const WTF::String& string)
147 {
148     WTF::StringImpl* impl = string.impl() ? string.impl() : WTF::StringImpl::empty();
149     RefPtr<WebKit::WebString> webString = WebKit::WebString::create(WTF::String(impl));
150     return toRef(webString.release().releaseRef());
151 }
152
153 inline WKURLRef toCopiedURLRef(const WTF::String& string)
154 {
155     WTF::StringImpl* impl = string.impl() ? string.impl() : WTF::StringImpl::empty();
156     RefPtr<WebKit::WebURL> webURL = WebKit::WebURL::create(WTF::String(impl));
157     return toRef(webURL.release().releaseRef());
158 }
159
160 /* Enum conversions */
161
162 inline WKTypeID toRef(WebKit::APIObject::Type type)
163 {
164     return static_cast<WKTypeID>(type);
165 }
166
167 inline WKFrameNavigationType toRef(WebCore::NavigationType type)
168 {
169     WKFrameNavigationType wkType = kWKFrameNavigationTypeOther;
170
171     switch (type) {
172     case WebCore::NavigationTypeLinkClicked:
173         wkType = kWKFrameNavigationTypeLinkClicked;
174         break;
175     case WebCore::NavigationTypeFormSubmitted:
176         wkType = kWKFrameNavigationTypeFormSubmitted;
177         break;
178     case WebCore::NavigationTypeBackForward:
179         wkType = kWKFrameNavigationTypeBackForward;
180         break;
181     case WebCore::NavigationTypeReload:
182         wkType = kWKFrameNavigationTypeReload;
183         break;
184     case WebCore::NavigationTypeFormResubmitted:
185         wkType = kWKFrameNavigationTypeFormResubmitted;
186         break;
187     case WebCore::NavigationTypeOther:
188         wkType = kWKFrameNavigationTypeOther;
189         break;
190     }
191     
192     return wkType;
193 }
194
195 inline WKEventModifiers toRef(WebKit::WebEvent::Modifiers modifiers)
196 {
197     WKEventModifiers wkModifiers = 0;
198     if (modifiers & WebKit::WebEvent::ShiftKey)
199         wkModifiers |= kWKEventModifiersShiftKey;
200     if (modifiers & WebKit::WebEvent::ControlKey)
201         wkModifiers |= kWKEventModifiersControlKey;
202     if (modifiers & WebKit::WebEvent::AltKey)
203         wkModifiers |= kWKEventModifiersAltKey;
204     if (modifiers & WebKit::WebEvent::MetaKey)
205         wkModifiers |= kWKEventModifiersMetaKey;
206     return wkModifiers;
207 }
208
209 #endif // WKAPICast_h