[iOS] DataTransfer.getData always returns the empty string when dropping text
[WebKit-https.git] / Source / WebKit / UIProcess / WebFrameProxy.cpp
1 /*
2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WebFrameProxy.h"
28
29 #include "WebCertificateInfo.h"
30 #include "WebFramePolicyListenerProxy.h"
31 #include "WebPageMessages.h"
32 #include "WebPageProxy.h"
33 #include "WebPasteboardProxy.h"
34 #include "WebProcessPool.h"
35 #include "WebsiteDataStore.h"
36 #include "WebsitePoliciesData.h"
37 #include <WebCore/Image.h>
38 #include <WebCore/MIMETypeRegistry.h>
39 #include <stdio.h>
40 #include <wtf/text/WTFString.h>
41
42 using namespace WebCore;
43
44 namespace WebKit {
45
46 WebFrameProxy::WebFrameProxy(WebPageProxy* page, uint64_t frameID)
47     : m_page(page)
48     , m_isFrameSet(false)
49     , m_frameID(frameID)
50 {
51     WebProcessPool::statistics().wkFrameCount++;
52 }
53
54 WebFrameProxy::~WebFrameProxy()
55 {
56     WebProcessPool::statistics().wkFrameCount--;
57 #if PLATFORM(GTK)
58     WebPasteboardProxy::singleton().didDestroyFrame(this);
59 #endif
60 }
61
62 void WebFrameProxy::webProcessWillShutDown()
63 {
64     m_page = nullptr;
65
66     if (m_activeListener) {
67         m_activeListener->invalidate();
68         m_activeListener = nullptr;
69     }
70 }
71
72 bool WebFrameProxy::isMainFrame() const
73 {
74     if (!m_page)
75         return false;
76
77     return this == m_page->mainFrame();
78 }
79
80 void WebFrameProxy::loadURL(const URL& url)
81 {
82     if (!m_page)
83         return;
84
85     m_page->process().send(Messages::WebPage::LoadURLInFrame(url, m_frameID), m_page->pageID());
86 }
87
88 void WebFrameProxy::stopLoading() const
89 {
90     if (!m_page)
91         return;
92
93     if (!m_page->isValid())
94         return;
95
96     m_page->process().send(Messages::WebPage::StopLoadingFrame(m_frameID), m_page->pageID());
97 }
98     
99 bool WebFrameProxy::canProvideSource() const
100 {
101     return isDisplayingMarkupDocument();
102 }
103
104 bool WebFrameProxy::canShowMIMEType(const String& mimeType) const
105 {
106     if (!m_page)
107         return false;
108
109     return m_page->canShowMIMEType(mimeType);
110 }
111
112 bool WebFrameProxy::isDisplayingStandaloneImageDocument() const
113 {
114     return Image::supportsType(m_MIMEType);
115 }
116
117 bool WebFrameProxy::isDisplayingStandaloneMediaDocument() const
118 {
119     return MIMETypeRegistry::isSupportedMediaMIMEType(m_MIMEType);
120 }
121
122 bool WebFrameProxy::isDisplayingMarkupDocument() const
123 {
124     // FIXME: This should be a call to a single MIMETypeRegistry function; adding a new one if needed.
125     // FIXME: This is doing case sensitive comparisons on MIME types, should be using ASCII case insensitive instead.
126     return m_MIMEType == "text/html" || m_MIMEType == "image/svg+xml" || m_MIMEType == "application/x-webarchive" || MIMETypeRegistry::isXMLMIMEType(m_MIMEType);
127 }
128
129 bool WebFrameProxy::isDisplayingPDFDocument() const
130 {
131     return MIMETypeRegistry::isPDFOrPostScriptMIMEType(m_MIMEType);
132 }
133
134 void WebFrameProxy::didStartProvisionalLoad(const URL& url)
135 {
136     m_frameLoadState.didStartProvisionalLoad(url);
137 }
138
139 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const URL& url)
140 {
141     m_frameLoadState.didReceiveServerRedirectForProvisionalLoad(url);
142 }
143
144 void WebFrameProxy::didFailProvisionalLoad()
145 {
146     m_frameLoadState.didFailProvisionalLoad();
147 }
148
149 void WebFrameProxy::didCommitLoad(const String& contentType, WebCertificateInfo& certificateInfo, bool containsPluginDocument)
150 {
151     m_frameLoadState.didCommitLoad();
152
153     m_title = String();
154     m_MIMEType = contentType;
155     m_isFrameSet = false;
156     m_certificateInfo = &certificateInfo;
157     m_containsPluginDocument = containsPluginDocument;
158 }
159
160 void WebFrameProxy::didFinishLoad()
161 {
162     m_frameLoadState.didFinishLoad();
163 }
164
165 void WebFrameProxy::didFailLoad()
166 {
167     m_frameLoadState.didFailLoad();
168 }
169
170 void WebFrameProxy::didSameDocumentNavigation(const URL& url)
171 {
172     m_frameLoadState.didSameDocumentNotification(url);
173 }
174
175 void WebFrameProxy::didChangeTitle(const String& title)
176 {
177     m_title = title;
178 }
179
180 void WebFrameProxy::receivedPolicyDecision(PolicyAction action, uint64_t listenerID, API::Navigation* navigation, std::optional<WebsitePoliciesData>&& data)
181 {
182     if (!m_page)
183         return;
184
185     ASSERT(m_activeListener);
186     ASSERT(m_activeListener->listenerID() == listenerID);
187     m_page->receivedPolicyDecision(action, *this, listenerID, navigation, WTFMove(data));
188 }
189
190 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID, PolicyListenerType policyListenerType)
191 {
192     if (m_activeListener)
193         m_activeListener->invalidate();
194     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID, policyListenerType);
195     return *static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
196 }
197
198 WebFramePolicyListenerProxy* WebFrameProxy::activePolicyListenerProxy()
199 {
200     if (!m_activeListener || m_activeListener->type() != WebFramePolicyListenerProxy::APIType)
201         return nullptr;
202
203     return static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
204 }
205
206 void WebFrameProxy::changeWebsiteDataStore(WebsiteDataStore& websiteDataStore)
207 {
208     if (!m_page)
209         return;
210
211     m_page->changeWebsiteDataStore(websiteDataStore);
212 }
213
214 void WebFrameProxy::getWebArchive(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
215 {
216     if (!m_page) {
217         callbackFunction(nullptr, CallbackBase::Error::Unknown);
218         return;
219     }
220
221     m_page->getWebArchiveOfFrame(this, WTFMove(callbackFunction));
222 }
223
224 void WebFrameProxy::getMainResourceData(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
225 {
226     if (!m_page) {
227         callbackFunction(nullptr, CallbackBase::Error::Unknown);
228         return;
229     }
230
231     m_page->getMainResourceDataOfFrame(this, WTFMove(callbackFunction));
232 }
233
234 void WebFrameProxy::getResourceData(API::URL* resourceURL, Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
235 {
236     if (!m_page) {
237         callbackFunction(nullptr, CallbackBase::Error::Unknown);
238         return;
239     }
240
241     m_page->getResourceDataFromFrame(this, resourceURL, WTFMove(callbackFunction));
242 }
243
244 void WebFrameProxy::setUnreachableURL(const URL& unreachableURL)
245 {
246     m_frameLoadState.setUnreachableURL(unreachableURL);
247 }
248
249 #if ENABLE(CONTENT_FILTERING)
250 bool WebFrameProxy::didHandleContentFilterUnblockNavigation(const ResourceRequest& request)
251 {
252     if (!m_contentFilterUnblockHandler.canHandleRequest(request)) {
253         m_contentFilterUnblockHandler = { };
254         return false;
255     }
256
257     RefPtr<WebPageProxy> page { m_page };
258     ASSERT(page);
259     m_contentFilterUnblockHandler.requestUnblockAsync([page](bool unblocked) {
260         if (unblocked)
261             page->reload({ });
262     });
263     return true;
264 }
265 #endif
266
267 #if PLATFORM(GTK)
268 void WebFrameProxy::collapseSelection()
269 {
270     if (!m_page)
271         return;
272
273     m_page->process().send(Messages::WebPage::CollapseSelectionInFrame(m_frameID), m_page->pageID());
274 }
275 #endif
276
277 } // namespace WebKit