2007-11-05 Mark Rowe <mrowe@apple.com>
[WebKit-https.git] / WebKit / gtk / WebCoreSupport / FrameLoaderClientGtk.cpp
1 /*
2  * Copyright (C) 2006 Don Gibson <dgibson77@gmail.com>
3  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
4  * Copyright (C) 2006, 2007 Apple Computer, Inc.  All rights reserved.
5  * Copyright (C) 2007 Trolltech ASA
6  * Copyright (C) 2007 Alp Toker <alp.toker@collabora.co.uk>
7  * Copyright (C) 2007 Holger Hans Peter Freyther
8  *
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
28  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32  
33 #include "config.h"
34 #include "FrameLoaderClientGtk.h"
35 #include "DocumentLoader.h"
36 #include "FrameLoader.h"
37 #include "FrameView.h"
38 #include "FrameTree.h"
39 #include "HTMLFormElement.h"
40 #include "HTMLFrameElement.h"
41 #include "HTMLFrameOwnerElement.h"
42 #include "HTMLNames.h"
43 #include "MIMETypeRegistry.h"
44 #include "NotImplemented.h"
45 #include "PlatformString.h"
46 #include "ResourceRequest.h"
47 #include "CString.h"
48 #include "ProgressTracker.h"
49 #include "webkitgtkpage.h"
50 #include "webkitgtkframe.h"
51 #include "webkitgtkprivate.h"
52 #include <stdio.h>
53
54 using namespace WebCore;
55
56 namespace WebKit {
57
58 FrameLoaderClient::FrameLoaderClient(WebKitFrame* frame)
59     : m_frame(frame)
60     , m_firstData(false)
61 {
62     ASSERT(m_frame);
63 }
64
65 String FrameLoaderClient::userAgent(const KURL&)
66 {
67     return "Mozilla/5.0 (X11; U; Linux i686; en-US) AppleWebKit/420+ (KHTML, like Gecko)";
68 }
69
70 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClient::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
71 {
72     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
73     return loader.release();
74 }
75
76 void FrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction policyFunction,  PassRefPtr<FormState>)
77 {
78     // FIXME: This is surely too simple
79     ASSERT(policyFunction);
80     if (!policyFunction)
81         return;
82     (core(m_frame)->loader()->*policyFunction)(PolicyUse);
83 }
84
85
86 void FrameLoaderClient::committedLoad(DocumentLoader* loader, const char* data, int length)
87 {
88     FrameLoader *fl = loader->frameLoader();
89     fl->setEncoding(m_response.textEncodingName(), false);
90     fl->addData(data, length);
91 }
92
93 void FrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
94 {
95     notImplemented();
96 }
97
98 void FrameLoaderClient::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
99 {
100     notImplemented();
101 }
102
103 void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long , ResourceRequest&, const ResourceResponse&)
104 {
105     notImplemented();
106 }
107
108 void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
109 {
110     notImplemented();   
111 }
112
113 void FrameLoaderClient::postProgressStartedNotification()
114 {
115     WebKitPage* page = getPageFromFrame(m_frame);
116     g_signal_emit_by_name(page, "load_started", m_frame);
117 }
118
119 void FrameLoaderClient::postProgressEstimateChangedNotification()
120 {
121     WebKitPage* kitPage = getPageFromFrame(m_frame);
122     Page* corePage = core(kitPage);
123
124     g_signal_emit_by_name(kitPage, "load_progress_changed", lround(corePage->progress()->estimatedProgress()*100)); 
125 }
126
127 void FrameLoaderClient::postProgressFinishedNotification()
128 {
129     WebKitPage* page = getPageFromFrame(m_frame);
130
131     g_signal_emit_by_name(page, "load_finished", m_frame);
132 }
133
134 void FrameLoaderClient::frameLoaderDestroyed()
135 {
136     m_frame = 0;
137     delete this;
138 }
139
140 void FrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse& response)
141 {
142     m_response = response;
143     m_firstData = true;
144 }
145
146 void FrameLoaderClient::dispatchDecidePolicyForMIMEType(FramePolicyFunction policyFunction, const String&, const ResourceRequest&)
147 {
148     // FIXME: we need to call directly here (comment copied from Qt version)
149     ASSERT(policyFunction);
150     if (!policyFunction)
151         return;
152     (core(m_frame)->loader()->*policyFunction)(PolicyUse);
153 }
154
155 void FrameLoaderClient::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction policyFunction, const NavigationAction&, const ResourceRequest&, const String&)
156 {
157     ASSERT(policyFunction);
158     if (!policyFunction)
159         return;
160     // FIXME: I think Qt version marshals this to another thread so when we
161     // have multi-threaded download, we might need to do the same
162     (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
163 }
164
165 void FrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction policyFunction, const NavigationAction&, const ResourceRequest&)
166 {
167     ASSERT(policyFunction);
168     if (!policyFunction)
169         return;
170     (core(m_frame)->loader()->*policyFunction)(PolicyUse);
171 }
172
173 Widget* FrameLoaderClient::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool)
174 {
175     notImplemented();
176     return 0;
177 }
178
179 PassRefPtr<Frame> FrameLoaderClient::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
180                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
181 {
182     Frame* coreFrame = core(webFrame());
183
184     ASSERT(core(getPageFromFrame(webFrame())) == coreFrame->page());
185     WebKitFrame* gtkFrame = WEBKIT_FRAME(webkit_frame_init_with_page(getPageFromFrame(webFrame()), ownerElement));
186     RefPtr<Frame> childFrame(adoptRef(core(gtkFrame)));
187
188     coreFrame->tree()->appendChild(childFrame);
189
190     childFrame->tree()->setName(name);
191     childFrame->init();
192     childFrame->loader()->load(url, referrer, FrameLoadTypeRedirectWithLockedHistory, String(), 0, 0);
193
194     // The frame's onload handler may have removed it from the document.
195     if (!childFrame->tree()->parent())
196         return 0;
197
198     // Propagate the marginwidth/height and scrolling modes to the view.
199     if (ownerElement->hasTagName(HTMLNames::frameTag) || ownerElement->hasTagName(HTMLNames::iframeTag)) {
200         HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);
201         if (frameElt->scrollingMode() == ScrollbarAlwaysOff)
202             childFrame->view()->setScrollbarsMode(ScrollbarAlwaysOff);
203         int marginWidth = frameElt->getMarginWidth();
204         int marginHeight = frameElt->getMarginHeight();
205         if (marginWidth != -1)
206             childFrame->view()->setMarginWidth(marginWidth);
207         if (marginHeight != -1)
208             childFrame->view()->setMarginHeight(marginHeight);
209     }
210
211     return childFrame.release();
212 }
213
214 void FrameLoaderClient::redirectDataToPlugin(Widget* pluginWidget)
215 {
216     notImplemented();
217     return;
218 }
219
220 Widget* FrameLoaderClient::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
221                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
222 {
223     notImplemented();
224     return 0;
225 }
226
227 ObjectContentType FrameLoaderClient::objectContentType(const KURL& url, const String& mimeType)
228 {
229     if (url.isEmpty())
230         return ObjectContentType();
231
232     // TODO: use more than just the extension to determine the content type?
233     String rtype = MIMETypeRegistry::getMIMETypeForPath(url.path());
234     if (!rtype.isEmpty())
235         return ObjectContentFrame;
236     return ObjectContentType();
237 }
238
239 String FrameLoaderClient::overrideMediaType() const
240 {
241     notImplemented();
242     return String();
243 }
244
245 void FrameLoaderClient::windowObjectCleared() const
246 {
247     g_signal_emit_by_name(m_frame, "cleared");
248 }
249
250 void FrameLoaderClient::didPerformFirstNavigation() const
251 {
252 }
253
254 void FrameLoaderClient::registerForIconNotification(bool) 
255
256     notImplemented(); 
257
258     
259
260 void FrameLoaderClient::setMainFrameDocumentReady(bool) 
261 {
262     // this is only interesting once we provide an external API for the DOM
263 }
264
265 bool FrameLoaderClient::hasWebView() const
266 {
267     notImplemented();
268     return true;
269 }
270
271 bool FrameLoaderClient::hasFrameView() const
272 {
273     notImplemented();
274     return true;
275 }
276
277 void FrameLoaderClient::dispatchDidFinishLoad() 
278
279     g_signal_emit_by_name(m_frame, "load_done", true);
280 }
281
282 void FrameLoaderClient::frameLoadCompleted() 
283 {
284     notImplemented(); 
285 }
286
287 void FrameLoaderClient::saveViewStateToItem(HistoryItem*)
288 {
289     notImplemented(); 
290 }
291
292 void FrameLoaderClient::restoreViewState()
293 {
294     notImplemented(); 
295 }
296
297 bool FrameLoaderClient::shouldGoToHistoryItem(HistoryItem* item) const 
298 {
299     // FIXME: This is a very simple implementation. More sophisticated
300     // implementation would delegate the decision to a PolicyDelegate.
301     // See mac implementation for example.
302     return item != 0;
303 }
304
305 bool FrameLoaderClient::privateBrowsingEnabled() const { notImplemented(); return false; }
306 void FrameLoaderClient::makeDocumentView() { notImplemented(); }
307 void FrameLoaderClient::makeRepresentation(DocumentLoader*) { notImplemented(); }
308 void FrameLoaderClient::forceLayout() { notImplemented(); }
309 void FrameLoaderClient::forceLayoutForNonHTML() { notImplemented(); }
310 void FrameLoaderClient::setCopiesOnScroll() { notImplemented(); }
311 void FrameLoaderClient::detachedFromParent1() { notImplemented(); }
312 void FrameLoaderClient::detachedFromParent2() { notImplemented(); }
313 void FrameLoaderClient::detachedFromParent3() { notImplemented(); }
314 void FrameLoaderClient::detachedFromParent4() { notImplemented(); }
315 void FrameLoaderClient::loadedFromCachedPage() { notImplemented(); }
316 void FrameLoaderClient::dispatchDidHandleOnloadEvents() {notImplemented(); }
317 void FrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad() { notImplemented(); }
318 void FrameLoaderClient::dispatchDidCancelClientRedirect() { notImplemented(); }
319 void FrameLoaderClient::dispatchWillPerformClientRedirect(const KURL&, double, double) { notImplemented(); }
320 void FrameLoaderClient::dispatchDidChangeLocationWithinPage() { notImplemented(); }
321 void FrameLoaderClient::dispatchWillClose() { notImplemented(); }
322
323 void FrameLoaderClient::dispatchDidReceiveIcon()
324 {
325     WebKitPage* page = getPageFromFrame(m_frame);
326
327     g_signal_emit_by_name(page, "icon_loaded", m_frame);
328 }
329
330 void FrameLoaderClient::dispatchDidStartProvisionalLoad()
331 {
332 }
333
334 void FrameLoaderClient::dispatchDidReceiveTitle(const String& title)
335 {
336     notImplemented();
337 }
338
339 void FrameLoaderClient::dispatchDidCommitLoad() { notImplemented(); }
340 void FrameLoaderClient::dispatchDidFinishDocumentLoad() { notImplemented(); }
341 void FrameLoaderClient::dispatchDidFirstLayout() { notImplemented(); }
342 void FrameLoaderClient::dispatchShow() { notImplemented(); }
343 void FrameLoaderClient::cancelPolicyCheck() { notImplemented(); }
344 void FrameLoaderClient::dispatchDidLoadMainResource(DocumentLoader*) { notImplemented(); }
345 void FrameLoaderClient::revertToProvisionalState(DocumentLoader*) { notImplemented(); }
346 void FrameLoaderClient::clearUnarchivingState(DocumentLoader*) { notImplemented(); }
347 void FrameLoaderClient::willChangeTitle(DocumentLoader*) { notImplemented(); }
348 void FrameLoaderClient::didChangeTitle(DocumentLoader *l) { setTitle(l->title(), l->URL()); }
349 void FrameLoaderClient::finalSetupForReplace(DocumentLoader*) { notImplemented(); }
350 void FrameLoaderClient::setDefersLoading(bool) { notImplemented(); }
351 bool FrameLoaderClient::isArchiveLoadPending(ResourceLoader*) const { notImplemented(); return false; }
352 void FrameLoaderClient::cancelPendingArchiveLoad(ResourceLoader*) { notImplemented(); }
353 void FrameLoaderClient::clearArchivedResources() { notImplemented(); }
354 bool FrameLoaderClient::canHandleRequest(const ResourceRequest&) const { notImplemented(); return true; }
355 bool FrameLoaderClient::canShowMIMEType(const String&) const { notImplemented(); return true; }
356 bool FrameLoaderClient::representationExistsForURLScheme(const String&) const { notImplemented(); return false; }
357 String FrameLoaderClient::generatedMIMETypeForURLScheme(const String&) const { notImplemented(); return String(); }
358
359 void FrameLoaderClient::finishedLoading(DocumentLoader* documentLoader)
360 {
361     ASSERT(documentLoader->frame());
362     // Setting the encoding on the frame loader is our way to get work done that is normally done
363     // when the first bit of data is received, even for the case of a document with no data (like about:blank).
364     String encoding = documentLoader->overrideEncoding();
365     bool userChosen = !encoding.isNull();
366     if (encoding.isNull())
367         encoding = documentLoader->response().textEncodingName();
368     documentLoader->frameLoader()->setEncoding(encoding, userChosen);
369 }
370
371
372 void FrameLoaderClient::provisionalLoadStarted()
373 {
374     notImplemented();
375 }
376
377 void FrameLoaderClient::didFinishLoad() {
378     notImplemented();
379 }
380
381 void FrameLoaderClient::prepareForDataSourceReplacement() { notImplemented(); }
382
383 void FrameLoaderClient::setTitle(const String& title, const KURL& url)
384 {
385     WebKitPage* page = getPageFromFrame(m_frame);
386
387     CString titleString = title.utf8(); 
388     DeprecatedCString urlString = url.prettyURL().utf8();
389     g_signal_emit_by_name(m_frame, "title_changed", titleString.data(), urlString.data());
390
391     if (m_frame == webkit_page_get_main_frame(page))
392         g_signal_emit_by_name(page, "title_changed", titleString.data(), urlString.data());
393 }
394
395 void FrameLoaderClient::setDocumentViewFromCachedPage(WebCore::CachedPage*) { notImplemented(); }
396 void FrameLoaderClient::dispatchDidReceiveContentLength(DocumentLoader*, unsigned long  identifier, int lengthReceived) { notImplemented(); }
397 void FrameLoaderClient::dispatchDidFinishLoading(DocumentLoader*, unsigned long  identifier) { notImplemented(); }
398 void FrameLoaderClient::dispatchDidFailLoading(DocumentLoader*, unsigned long  identifier, const ResourceError&) { notImplemented(); }
399 bool FrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length) { notImplemented(); return false; }
400
401 void FrameLoaderClient::dispatchDidFailProvisionalLoad(const ResourceError&)
402 {
403     g_signal_emit_by_name(m_frame, "load_done", false);
404 }
405
406 void FrameLoaderClient::dispatchDidFailLoad(const ResourceError&)
407 {
408     g_signal_emit_by_name(m_frame, "load_done", false);
409 }
410
411 void FrameLoaderClient::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&) { notImplemented(); }
412 ResourceError FrameLoaderClient::cancelledError(const ResourceRequest&) { notImplemented(); return ResourceError(); }
413 ResourceError FrameLoaderClient::blockedError(const ResourceRequest&) { notImplemented(); return ResourceError(); }
414 ResourceError FrameLoaderClient::cannotShowURLError(const ResourceRequest&) { notImplemented(); return ResourceError(); }
415 ResourceError FrameLoaderClient::interruptForPolicyChangeError(const ResourceRequest&) { notImplemented(); return ResourceError(); }
416 ResourceError FrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse&) { notImplemented(); return ResourceError(); }
417 ResourceError FrameLoaderClient::fileDoesNotExistError(const ResourceResponse&) { notImplemented(); return ResourceError(); }
418 bool FrameLoaderClient::shouldFallBack(const ResourceError&) { notImplemented(); return false; }
419 bool FrameLoaderClient::willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL& originalURL) const { notImplemented(); return false; }
420 void FrameLoaderClient::saveDocumentViewToCachedPage(CachedPage*) { notImplemented(); }
421 bool FrameLoaderClient::canCachePage() const { notImplemented(); return false; }
422 Frame* FrameLoaderClient::dispatchCreatePage() { notImplemented(); return 0; }
423 void FrameLoaderClient::dispatchUnableToImplementPolicy(const ResourceError&) { notImplemented(); }
424 void FrameLoaderClient::setMainDocumentError(DocumentLoader*, const ResourceError&) { notImplemented(); }
425 void FrameLoaderClient::startDownload(const ResourceRequest&) { notImplemented(); }
426 void FrameLoaderClient::updateGlobalHistoryForStandardLoad(const KURL&) { notImplemented(); }
427 void FrameLoaderClient::updateGlobalHistoryForReload(const KURL&) { notImplemented(); }
428
429 }