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