Web Inspector: "Reload Web Inspector" button no longer partially works
[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 "WebCertificateInfo.h"
31 #include "WebFramePolicyListenerProxy.h"
32 #include "WebPageMessages.h"
33 #include "WebPageProxy.h"
34 #include "WebPasteboardProxy.h"
35 #include "WebProcessPool.h"
36 #include "WebsiteDataStore.h"
37 #include "WebsitePoliciesData.h"
38 #include <WebCore/Image.h>
39 #include <WebCore/MIMETypeRegistry.h>
40 #include <stdio.h>
41 #include <wtf/text/WTFString.h>
42
43 namespace WebKit {
44 using namespace WebCore;
45
46 WebFrameProxy::WebFrameProxy(WebPageProxy& page, uint64_t frameID)
47     : m_page(makeWeakPtr(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->ignore();
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 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient, RefPtr<SafeBrowsingWarning>&&)>&& completionHandler, ShouldExpectSafeBrowsingResult expect)
181 {
182     if (m_activeListener)
183         m_activeListener->ignore();
184     m_activeListener = WebFramePolicyListenerProxy::create([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (WebCore::PolicyAction action, API::WebsitePolicies* policies, ProcessSwapRequestedByClient processSwapRequestedByClient, RefPtr<SafeBrowsingWarning>&& safeBrowsingWarning) mutable {
185         completionHandler(action, policies, processSwapRequestedByClient, WTFMove(safeBrowsingWarning));
186         m_activeListener = nullptr;
187     }, expect);
188     return *m_activeListener;
189 }
190
191 void WebFrameProxy::getWebArchive(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
192 {
193     if (!m_page) {
194         callbackFunction(nullptr, CallbackBase::Error::Unknown);
195         return;
196     }
197
198     m_page->getWebArchiveOfFrame(this, WTFMove(callbackFunction));
199 }
200
201 void WebFrameProxy::getMainResourceData(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
202 {
203     if (!m_page) {
204         callbackFunction(nullptr, CallbackBase::Error::Unknown);
205         return;
206     }
207
208     m_page->getMainResourceDataOfFrame(this, WTFMove(callbackFunction));
209 }
210
211 void WebFrameProxy::getResourceData(API::URL* resourceURL, Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
212 {
213     if (!m_page) {
214         callbackFunction(nullptr, CallbackBase::Error::Unknown);
215         return;
216     }
217
218     m_page->getResourceDataFromFrame(this, resourceURL, WTFMove(callbackFunction));
219 }
220
221 void WebFrameProxy::setUnreachableURL(const URL& unreachableURL)
222 {
223     m_frameLoadState.setUnreachableURL(unreachableURL);
224 }
225
226 #if ENABLE(CONTENT_FILTERING)
227 bool WebFrameProxy::didHandleContentFilterUnblockNavigation(const ResourceRequest& request)
228 {
229     if (!m_contentFilterUnblockHandler.canHandleRequest(request)) {
230         m_contentFilterUnblockHandler = { };
231         return false;
232     }
233
234     RefPtr<WebPageProxy> page { m_page.get() };
235     ASSERT(page);
236     m_contentFilterUnblockHandler.requestUnblockAsync([page](bool unblocked) {
237         if (unblocked)
238             page->reload({ });
239     });
240     return true;
241 }
242 #endif
243
244 #if PLATFORM(GTK)
245 void WebFrameProxy::collapseSelection()
246 {
247     if (!m_page)
248         return;
249
250     m_page->process().send(Messages::WebPage::CollapseSelectionInFrame(m_frameID), m_page->pageID());
251 }
252 #endif
253
254 } // namespace WebKit