c43b8e0eb5326b7dff6a2a58be1b9d9883c2164d
[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_provisionalLoadRedirectChain = { url };
135
136     m_frameLoadState.didStartProvisionalLoad(url);
137 }
138
139 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const URL& url)
140 {
141     // didReceiveServerRedirectForProvisionalLoad() often gets called twice for the same redirect.
142     if (m_provisionalLoadRedirectChain.isEmpty() || m_provisionalLoadRedirectChain.last() != url)
143         m_provisionalLoadRedirectChain.append(url);
144
145     m_frameLoadState.didReceiveServerRedirectForProvisionalLoad(url);
146 }
147
148 void WebFrameProxy::didFailProvisionalLoad()
149 {
150     m_provisionalLoadRedirectChain.clear();
151     m_frameLoadState.didFailProvisionalLoad();
152 }
153
154 void WebFrameProxy::didCommitLoad(const String& contentType, WebCertificateInfo& certificateInfo, bool containsPluginDocument)
155 {
156     m_frameLoadState.didCommitLoad();
157
158     m_title = String();
159     m_MIMEType = contentType;
160     m_isFrameSet = false;
161     m_certificateInfo = &certificateInfo;
162     m_containsPluginDocument = containsPluginDocument;
163 }
164
165 void WebFrameProxy::didFinishLoad()
166 {
167     m_provisionalLoadRedirectChain.clear();
168     m_frameLoadState.didFinishLoad();
169 }
170
171 void WebFrameProxy::didFailLoad()
172 {
173     m_provisionalLoadRedirectChain.clear();
174     m_frameLoadState.didFailLoad();
175 }
176
177 void WebFrameProxy::didSameDocumentNavigation(const URL& url)
178 {
179     m_frameLoadState.didSameDocumentNotification(url);
180 }
181
182 void WebFrameProxy::didChangeTitle(const String& title)
183 {
184     m_title = title;
185 }
186
187 void WebFrameProxy::receivedPolicyDecision(PolicyAction action, uint64_t listenerID, API::Navigation* navigation, const WebsitePolicies& websitePolicies)
188 {
189     if (!m_page)
190         return;
191
192     ASSERT(m_activeListener);
193     ASSERT(m_activeListener->listenerID() == listenerID);
194     m_page->receivedPolicyDecision(action, *this, listenerID, navigation, websitePolicies);
195 }
196
197 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
198 {
199     if (m_activeListener)
200         m_activeListener->invalidate();
201     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
202     return *static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
203 }
204
205 void WebFrameProxy::getWebArchive(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
206 {
207     if (!m_page) {
208         callbackFunction(nullptr, CallbackBase::Error::Unknown);
209         return;
210     }
211
212     m_page->getWebArchiveOfFrame(this, WTFMove(callbackFunction));
213 }
214
215 void WebFrameProxy::getMainResourceData(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
216 {
217     if (!m_page) {
218         callbackFunction(nullptr, CallbackBase::Error::Unknown);
219         return;
220     }
221
222     m_page->getMainResourceDataOfFrame(this, WTFMove(callbackFunction));
223 }
224
225 void WebFrameProxy::getResourceData(API::URL* resourceURL, Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
226 {
227     if (!m_page) {
228         callbackFunction(nullptr, CallbackBase::Error::Unknown);
229         return;
230     }
231
232     m_page->getResourceDataFromFrame(this, resourceURL, WTFMove(callbackFunction));
233 }
234
235 void WebFrameProxy::setUnreachableURL(const URL& unreachableURL)
236 {
237     m_frameLoadState.setUnreachableURL(unreachableURL);
238 }
239
240 #if ENABLE(CONTENT_FILTERING)
241 bool WebFrameProxy::didHandleContentFilterUnblockNavigation(const ResourceRequest& request)
242 {
243     if (!m_contentFilterUnblockHandler.canHandleRequest(request)) {
244         m_contentFilterUnblockHandler = { };
245         return false;
246     }
247
248     RefPtr<WebPageProxy> page { m_page };
249     ASSERT(page);
250     m_contentFilterUnblockHandler.requestUnblockAsync([page](bool unblocked) {
251         if (unblocked)
252             page->reload({ });
253     });
254     return true;
255 }
256 #endif
257
258 #if PLATFORM(GTK)
259 void WebFrameProxy::collapseSelection()
260 {
261     if (!m_page)
262         return;
263
264     m_page->process().send(Messages::WebPage::CollapseSelectionInFrame(m_frameID), m_page->pageID());
265 }
266 #endif
267
268 } // namespace WebKit