Move more state tracking to FrameLoadState
[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 "WebContext.h"
31 #include "WebFormSubmissionListenerProxy.h"
32 #include "WebFramePolicyListenerProxy.h"
33 #include "WebPageMessages.h"
34 #include "WebPageProxy.h"
35 #include <WebCore/DOMImplementation.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     WebContext::statistics().wkFrameCount++;
51 }
52
53 WebFrameProxy::~WebFrameProxy()
54 {
55     WebContext::statistics().wkFrameCount--;
56 }
57
58 void WebFrameProxy::disconnect()
59 {
60     m_page = 0;
61
62     if (m_activeListener) {
63         m_activeListener->invalidate();
64         m_activeListener = 0;
65     }
66 }
67
68 bool WebFrameProxy::isMainFrame() const
69 {
70     if (!m_page)
71         return false;
72
73     return this == m_page->mainFrame();
74 }
75
76 void WebFrameProxy::stopLoading() const
77 {
78     if (!m_page)
79         return;
80
81     if (!m_page->isValid())
82         return;
83
84     m_page->process()->send(Messages::WebPage::StopLoadingFrame(m_frameID), m_page->pageID());
85 }
86     
87 bool WebFrameProxy::canProvideSource() const
88 {
89     return isDisplayingMarkupDocument();
90 }
91
92 bool WebFrameProxy::canShowMIMEType(const String& mimeType) const
93 {
94     if (!m_page)
95         return false;
96
97     return m_page->canShowMIMEType(mimeType);
98 }
99
100 bool WebFrameProxy::isDisplayingStandaloneImageDocument() const
101 {
102     return Image::supportsType(m_MIMEType);
103 }
104
105 bool WebFrameProxy::isDisplayingMarkupDocument() const
106 {
107     // FIXME: This check should be moved to somewhere in WebCore.
108     return m_MIMEType == "text/html" || m_MIMEType == "image/svg+xml" || m_MIMEType == "application/x-webarchive" || DOMImplementation::isXMLMIMEType(m_MIMEType);
109 }
110
111 bool WebFrameProxy::isDisplayingPDFDocument() const
112 {
113     if (m_MIMEType.isEmpty())
114         return false;
115
116     return MIMETypeRegistry::isPDFOrPostScriptMIMEType(m_MIMEType);
117 }
118
119 void WebFrameProxy::didStartProvisionalLoad(const String& url)
120 {
121     m_frameLoadState.didStartProvisionalLoad(url);
122 }
123
124 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const String& url)
125 {
126     m_frameLoadState.didReceiveServerRedirectForProvisionalLoad(url);
127 }
128
129 void WebFrameProxy::didFailProvisionalLoad()
130 {
131     m_frameLoadState.didFailProvisionalLoad();
132 }
133
134 void WebFrameProxy::didCommitLoad(const String& contentType, const PlatformCertificateInfo& certificateInfo)
135 {
136     m_frameLoadState.didCommitLoad();
137
138     m_title = String();
139     m_MIMEType = contentType;
140     m_isFrameSet = false;
141     m_certificateInfo = WebCertificateInfo::create(certificateInfo);
142 }
143
144 void WebFrameProxy::didFinishLoad()
145 {
146     m_frameLoadState.didFinishLoad();
147 }
148
149 void WebFrameProxy::didFailLoad()
150 {
151     m_frameLoadState.didFailLoad();
152 }
153
154 void WebFrameProxy::didSameDocumentNavigation(const String& url)
155 {
156     m_frameLoadState.didSameDocumentNotification(url);
157 }
158
159 void WebFrameProxy::didChangeTitle(const String& title)
160 {
161     m_title = title;
162 }
163
164 void WebFrameProxy::receivedPolicyDecision(WebCore::PolicyAction action, uint64_t listenerID)
165 {
166     if (!m_page)
167         return;
168
169     ASSERT(m_activeListener);
170     ASSERT(m_activeListener->listenerID() == listenerID);
171     m_page->receivedPolicyDecision(action, this, listenerID);
172 }
173
174 WebFramePolicyListenerProxy* WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
175 {
176     if (m_activeListener)
177         m_activeListener->invalidate();
178     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
179     return static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
180 }
181
182 WebFormSubmissionListenerProxy* WebFrameProxy::setUpFormSubmissionListenerProxy(uint64_t listenerID)
183 {
184     if (m_activeListener)
185         m_activeListener->invalidate();
186     m_activeListener = WebFormSubmissionListenerProxy::create(this, listenerID);
187     return static_cast<WebFormSubmissionListenerProxy*>(m_activeListener.get());
188 }
189
190 void WebFrameProxy::getWebArchive(PassRefPtr<DataCallback> callback)
191 {
192     if (!m_page) {
193         callback->invalidate();
194         return;
195     }
196
197     m_page->getWebArchiveOfFrame(this, callback);
198 }
199
200 void WebFrameProxy::getMainResourceData(PassRefPtr<DataCallback> callback)
201 {
202     if (!m_page) {
203         callback->invalidate();
204         return;
205     }
206
207     m_page->getMainResourceDataOfFrame(this, callback);
208 }
209
210 void WebFrameProxy::getResourceData(WebURL* resourceURL, PassRefPtr<DataCallback> callback)
211 {
212     if (!m_page) {
213         callback->invalidate();
214         return;
215     }
216
217     m_page->getResourceDataFromFrame(this, resourceURL, callback);
218 }
219
220 void WebFrameProxy::setUnreachableURL(const String& unreachableURL)
221 {
222     m_frameLoadState.setUnreachableURL(unreachableURL);
223 }
224
225 } // namespace WebKit