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