[WK2] Add API to query if a download was user-initiated
[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 <WebCore/Image.h>
36 #include <WebCore/MIMETypeRegistry.h>
37 #include <stdio.h>
38 #include <wtf/text/WTFString.h>
39
40 using namespace WebCore;
41
42 namespace WebKit {
43
44 WebFrameProxy::WebFrameProxy(WebPageProxy* page, uint64_t frameID)
45     : m_page(page)
46     , m_isFrameSet(false)
47     , m_frameID(frameID)
48 {
49     WebProcessPool::statistics().wkFrameCount++;
50 }
51
52 WebFrameProxy::~WebFrameProxy()
53 {
54     WebProcessPool::statistics().wkFrameCount--;
55 #if PLATFORM(GTK)
56     WebPasteboardProxy::singleton().didDestroyFrame(this);
57 #endif
58 }
59
60 void WebFrameProxy::webProcessWillShutDown()
61 {
62     m_page = nullptr;
63
64     if (m_activeListener) {
65         m_activeListener->invalidate();
66         m_activeListener = nullptr;
67     }
68 }
69
70 bool WebFrameProxy::isMainFrame() const
71 {
72     if (!m_page)
73         return false;
74
75     return this == m_page->mainFrame();
76 }
77
78 void WebFrameProxy::loadURL(const URL& url)
79 {
80     if (!m_page)
81         return;
82
83     m_page->process().send(Messages::WebPage::LoadURLInFrame(url, m_frameID), m_page->pageID());
84 }
85
86 void WebFrameProxy::stopLoading() const
87 {
88     if (!m_page)
89         return;
90
91     if (!m_page->isValid())
92         return;
93
94     m_page->process().send(Messages::WebPage::StopLoadingFrame(m_frameID), m_page->pageID());
95 }
96     
97 bool WebFrameProxy::canProvideSource() const
98 {
99     return isDisplayingMarkupDocument();
100 }
101
102 bool WebFrameProxy::canShowMIMEType(const String& mimeType) const
103 {
104     if (!m_page)
105         return false;
106
107     return m_page->canShowMIMEType(mimeType);
108 }
109
110 bool WebFrameProxy::isDisplayingStandaloneImageDocument() const
111 {
112     return Image::supportsType(m_MIMEType);
113 }
114
115 bool WebFrameProxy::isDisplayingStandaloneMediaDocument() const
116 {
117     return MIMETypeRegistry::isSupportedMediaMIMEType(m_MIMEType);
118 }
119
120 bool WebFrameProxy::isDisplayingMarkupDocument() const
121 {
122     // FIXME: This should be a call to a single MIMETypeRegistry function; adding a new one if needed.
123     // FIXME: This is doing case sensitive comparisons on MIME types, should be using ASCII case insensitive instead.
124     return m_MIMEType == "text/html" || m_MIMEType == "image/svg+xml" || m_MIMEType == "application/x-webarchive" || MIMETypeRegistry::isXMLMIMEType(m_MIMEType);
125 }
126
127 bool WebFrameProxy::isDisplayingPDFDocument() const
128 {
129     return MIMETypeRegistry::isPDFOrPostScriptMIMEType(m_MIMEType);
130 }
131
132 void WebFrameProxy::didStartProvisionalLoad(const URL& url)
133 {
134     m_frameLoadState.didStartProvisionalLoad(url);
135 }
136
137 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const URL& url)
138 {
139     m_frameLoadState.didReceiveServerRedirectForProvisionalLoad(url);
140 }
141
142 void WebFrameProxy::didFailProvisionalLoad()
143 {
144     m_frameLoadState.didFailProvisionalLoad();
145 }
146
147 void WebFrameProxy::didCommitLoad(const String& contentType, WebCertificateInfo& certificateInfo, bool containsPluginDocument)
148 {
149     m_frameLoadState.didCommitLoad();
150
151     m_title = String();
152     m_MIMEType = contentType;
153     m_isFrameSet = false;
154     m_certificateInfo = &certificateInfo;
155     m_containsPluginDocument = containsPluginDocument;
156 }
157
158 void WebFrameProxy::didFinishLoad()
159 {
160     m_frameLoadState.didFinishLoad();
161 }
162
163 void WebFrameProxy::didFailLoad()
164 {
165     m_frameLoadState.didFailLoad();
166 }
167
168 void WebFrameProxy::didSameDocumentNavigation(const URL& url)
169 {
170     m_frameLoadState.didSameDocumentNotification(url);
171 }
172
173 void WebFrameProxy::didChangeTitle(const String& title)
174 {
175     m_title = title;
176 }
177
178 void WebFrameProxy::receivedPolicyDecision(PolicyAction action, uint64_t listenerID, API::Navigation* navigation, const WebsitePolicies& websitePolicies)
179 {
180     if (!m_page)
181         return;
182
183     ASSERT(m_activeListener);
184     ASSERT(m_activeListener->listenerID() == listenerID);
185     m_page->receivedPolicyDecision(action, *this, listenerID, navigation, websitePolicies);
186 }
187
188 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
189 {
190     if (m_activeListener)
191         m_activeListener->invalidate();
192     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
193     return *static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
194 }
195
196 void WebFrameProxy::getWebArchive(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
197 {
198     if (!m_page) {
199         callbackFunction(nullptr, CallbackBase::Error::Unknown);
200         return;
201     }
202
203     m_page->getWebArchiveOfFrame(this, WTFMove(callbackFunction));
204 }
205
206 void WebFrameProxy::getMainResourceData(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
207 {
208     if (!m_page) {
209         callbackFunction(nullptr, CallbackBase::Error::Unknown);
210         return;
211     }
212
213     m_page->getMainResourceDataOfFrame(this, WTFMove(callbackFunction));
214 }
215
216 void WebFrameProxy::getResourceData(API::URL* resourceURL, Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
217 {
218     if (!m_page) {
219         callbackFunction(nullptr, CallbackBase::Error::Unknown);
220         return;
221     }
222
223     m_page->getResourceDataFromFrame(this, resourceURL, WTFMove(callbackFunction));
224 }
225
226 void WebFrameProxy::setUnreachableURL(const URL& unreachableURL)
227 {
228     m_frameLoadState.setUnreachableURL(unreachableURL);
229 }
230
231 #if ENABLE(CONTENT_FILTERING)
232 bool WebFrameProxy::didHandleContentFilterUnblockNavigation(const ResourceRequest& request)
233 {
234     if (!m_contentFilterUnblockHandler.canHandleRequest(request)) {
235         m_contentFilterUnblockHandler = { };
236         return false;
237     }
238
239     RefPtr<WebPageProxy> page { m_page };
240     ASSERT(page);
241     m_contentFilterUnblockHandler.requestUnblockAsync([page](bool unblocked) {
242         if (unblocked)
243             page->reload({ });
244     });
245     return true;
246 }
247 #endif
248
249 #if PLATFORM(GTK)
250 void WebFrameProxy::collapseSelection()
251 {
252     if (!m_page)
253         return;
254
255     m_page->process().send(Messages::WebPage::CollapseSelectionInFrame(m_frameID), m_page->pageID());
256 }
257 #endif
258
259 } // namespace WebKit