WebKit/qt/WebCoreSupport/FrameLoaderClientQt.cpp

   1 /*
   2  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
   3  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
   4  * Copyright (C) 2007-2008 Trolltech ASA
   5  *
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  25  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "config.h"
  31 #include "CSSComputedStyleDeclaration.h"
  32 #include "CSSPropertyNames.h"
  33 #include "FrameLoaderClientQt.h"
  34 #include "FrameTree.h"
  35 #include "FrameView.h"
  36 #include "DocumentLoader.h"
  37 #include "MIMETypeRegistry.h"
  38 #include "ResourceResponse.h"
  39 #include "Page.h"
  40 #include "PluginData.h"
  41 #include "ProgressTracker.h"
  42 #include "RenderPart.h"
  43 #include "ResourceRequest.h"
  44 #include "HistoryItem.h"
  45 #include "HTMLFormElement.h"
  46 #include "NotImplemented.h"
  47 #include "QNetworkReplyHandler.h"
  48 #include "ResourceHandleInternal.h"
  49 #include "ResourceHandle.h"
  50
  51 #include "qwebpage.h"
  52 #include "qwebframe.h"
  53 #include "qwebframe_p.h"
  54 #include "qwebhistoryinterface.h"
  55 #include "qwebpluginfactory.h"
  56
  57 #include <qfileinfo.h>
  58
  59 #include <QCoreApplication>
  60 #include <QDebug>
  61 #if QT_VERSION >= 0x040400
  62 #include <QNetworkRequest>
  63 #include <QNetworkReply>
  64 #else
  65 #include "qwebnetworkinterface_p.h"
  66 #endif
  67
  68 static bool dumpFrameLoaderCallbacks = false;
  69
  70 void QWEBKIT_EXPORT qt_dump_frame_loader(bool b)
  71 {
  72     dumpFrameLoaderCallbacks = b;
  73 }
  74
  75 // Compare with WebKitTools/DumpRenderTree/mac/FrameLoadDelegate.mm
  76 static QString drtDescriptionSuitableForTestResult(WebCore::Frame* _frame)
  77 {
  78     QWebFrame* frame = QWebFramePrivate::kit(_frame);
  79     QString name = frame->name();
  80
  81     bool isMainFrame = frame == frame->page()->mainFrame();
  82     if (isMainFrame) {
  83         if (!name.isEmpty())
  84             return QString::fromLatin1("main frame \"%1\"").arg(name);
  85         return QLatin1String("main frame");
  86     } else {
  87         if (!name.isEmpty())
  88             return QString::fromLatin1("frame \"%1\"").arg(name);
  89         return QLatin1String("frame (anonymous)");
  90     }
  91 }
  92
  93 static QString drtDescriptionSuitableForTestResult(const WebCore::KURL& _url)
  94 {
  95     QUrl url = _url;
  96     return url.toString();
  97 }
  98
  99
 100 namespace WebCore
 101 {
 102
 103 FrameLoaderClientQt::FrameLoaderClientQt()
 104     : m_frame(0)
 105     , m_webFrame(0)
 106     , m_firstData(false)
 107     , m_policyFunction(0)
 108 {
 109     connect(this, SIGNAL(sigCallPolicyFunction(int)), this, SLOT(slotCallPolicyFunction(int)), Qt::QueuedConnection);
 110 }
 111
 112
 113 FrameLoaderClientQt::~FrameLoaderClientQt()
 114 {
 115 }
 116
 117 void FrameLoaderClientQt::setFrame(QWebFrame* webFrame, Frame* frame)
 118 {
 119     m_webFrame = webFrame;
 120     m_frame = frame;
 121     if (!m_webFrame || !m_webFrame->page()) {
 122         qWarning("FrameLoaderClientQt::setFrame frame without Page!");
 123         return;
 124     }
 125
 126     connect(this, SIGNAL(loadStarted()),
 127             m_webFrame, SIGNAL(loadStarted()));
 128     connect(this, SIGNAL(loadProgressChanged(int)),
 129             m_webFrame->page(), SIGNAL(loadProgressChanged(int)));
 130     connect(this, SIGNAL(loadFinished()),
 131             m_webFrame, SIGNAL(loadFinished()));
 132     connect(this, SIGNAL(titleChanged(const QString&)),
 133             m_webFrame, SIGNAL(titleChanged(const QString&)));
 134 }
 135
 136 QWebFrame* FrameLoaderClientQt::webFrame() const
 137 {
 138     return m_webFrame;
 139 }
 140
 141 void FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
 142 {
 143     ASSERT(!m_policyFunction);
 144     ASSERT(function);
 145
 146     m_policyFunction = function;
 147     emit sigCallPolicyFunction(action);
 148 }
 149
 150 void FrameLoaderClientQt::slotCallPolicyFunction(int action)
 151 {
 152     if (!m_frame || !m_policyFunction)
 153         return;
 154     FramePolicyFunction function = m_policyFunction;
 155     m_policyFunction = 0;
 156     (m_frame->loader()->*function)(WebCore::PolicyAction(action));
 157 }
 158
 159 bool FrameLoaderClientQt::hasWebView() const
 160 {
 161     //notImplemented();
 162     return true;
 163 }
 164
 165
 166 bool FrameLoaderClientQt::hasFrameView() const
 167 {
 168     //notImplemented();
 169     return true;
 170 }
 171
 172 void FrameLoaderClientQt::savePlatformDataToCachedPage(CachedPage*)
 173 {
 174     notImplemented();
 175 }
 176
 177 void FrameLoaderClientQt::transitionToCommittedFromCachedPage(CachedPage*)
 178 {
 179 }
 180
 181 void FrameLoaderClientQt::transitionToCommittedForNewPage()
 182 {
 183     ASSERT(m_frame);
 184     ASSERT(m_webFrame);
 185
 186     Page* page = m_frame->page();
 187     ASSERT(page);
 188
 189     bool isMainFrame = m_frame == page->mainFrame();
 190
 191     m_frame->setView(0);
 192
 193     FrameView* frameView;
 194     if (isMainFrame)
 195         frameView = new FrameView(m_frame, m_webFrame->page()->viewportSize());
 196     else
 197         frameView = new FrameView(m_frame);
 198
 199     if (!m_webFrame->d->allowsScrolling)
 200         frameView->setScrollbarsMode(ScrollbarAlwaysOff);
 201     if (m_webFrame->d->marginWidth != -1)
 202         frameView->setMarginWidth(m_webFrame->d->marginWidth);
 203     if (m_webFrame->d->marginHeight != -1)
 204         frameView->setMarginHeight(m_webFrame->d->marginHeight);
 205     if (m_webFrame->d->horizontalScrollBarPolicy != Qt::ScrollBarAsNeeded)
 206         frameView->setHScrollbarMode((ScrollbarMode)m_webFrame->d->horizontalScrollBarPolicy);
 207     if (m_webFrame->d->verticalScrollBarPolicy != Qt::ScrollBarAsNeeded)
 208         frameView->setVScrollbarMode((ScrollbarMode)m_webFrame->d->verticalScrollBarPolicy);
 209
 210     m_frame->setView(frameView);
 211     // FrameViews are created with a ref count of 1. Release this ref since we've assigned it to frame.
 212     frameView->deref();
 213
 214     if (m_frame->ownerRenderer())
 215         m_frame->ownerRenderer()->setWidget(frameView);
 216 }
 217
 218
 219 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
 220 {
 221     // don't need this for now I think.
 222 }
 223
 224
 225 void FrameLoaderClientQt::forceLayout()
 226 {
 227     m_frame->forceLayout(true);
 228 }
 229
 230
 231 void FrameLoaderClientQt::forceLayoutForNonHTML()
 232 {
 233 }
 234
 235
 236 void FrameLoaderClientQt::setCopiesOnScroll()
 237 {
 238     // apparently mac specific
 239 }
 240
 241
 242 void FrameLoaderClientQt::detachedFromParent2()
 243 {
 244 }
 245
 246
 247 void FrameLoaderClientQt::detachedFromParent3()
 248 {
 249 }
 250
 251
 252 void FrameLoaderClientQt::detachedFromParent4()
 253 {
 254 }
 255
 256 void FrameLoaderClientQt::dispatchDidHandleOnloadEvents()
 257 {
 258     // don't need this one
 259     if (dumpFrameLoaderCallbacks)
 260         printf("%s - didHandleOnloadEventsForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 261
 262 }
 263
 264
 265 void FrameLoaderClientQt::dispatchDidReceiveServerRedirectForProvisionalLoad()
 266 {
 267     if (dumpFrameLoaderCallbacks)
 268         printf("%s - didReceiveServerRedirectForProvisionalLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 269
 270     notImplemented();
 271 }
 272
 273
 274 void FrameLoaderClientQt::dispatchDidCancelClientRedirect()
 275 {
 276     if (dumpFrameLoaderCallbacks)
 277         printf("%s - didCancelClientRedirectForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 278
 279     notImplemented();
 280 }
 281
 282
 283 void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const KURL& url,
 284                                                             double interval,
 285                                                             double fireDate)
 286 {
 287     if (dumpFrameLoaderCallbacks)
 288         printf("%s - willPerformClientRedirectToURL: %s \n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)), qPrintable(drtDescriptionSuitableForTestResult(url)));
 289
 290     notImplemented();
 291 }
 292
 293
 294 void FrameLoaderClientQt::dispatchDidChangeLocationWithinPage()
 295 {
 296     if (dumpFrameLoaderCallbacks)
 297         printf("%s - didChangeLocationWithinPageForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 298
 299     notImplemented();
 300 }
 301
 302
 303 void FrameLoaderClientQt::dispatchWillClose()
 304 {
 305     if (dumpFrameLoaderCallbacks)
 306         printf("%s - willCloseFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 307 }
 308
 309
 310 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
 311 {
 312     if (dumpFrameLoaderCallbacks)
 313         printf("%s - didStartProvisionalLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 314
 315     if (m_webFrame)
 316         emit m_webFrame->provisionalLoad();
 317 }
 318
 319
 320 void FrameLoaderClientQt::dispatchDidReceiveTitle(const String& title)
 321 {
 322     if (dumpFrameLoaderCallbacks)
 323         printf("%s - didReceiveTitle: %s\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)), qPrintable(QString(title)));
 324
 325     if (!m_webFrame)
 326         return;
 327
 328
 329
 330     // ### hack
 331     emit m_webFrame->urlChanged(m_webFrame->url());
 332     emit titleChanged(title);
 333 }
 334
 335
 336 void FrameLoaderClientQt::dispatchDidCommitLoad()
 337 {
 338     if (dumpFrameLoaderCallbacks)
 339         printf("%s - didCommitLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 340
 341     if (m_frame->tree()->parent() || !m_webFrame)
 342         return;
 343
 344     m_webFrame->page()->d->updateNavigationActions();
 345 }
 346
 347
 348 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
 349 {
 350     if (dumpFrameLoaderCallbacks)
 351         printf("%s - didFinishDocumentLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 352
 353     if (m_frame->tree()->parent() || !m_webFrame)
 354         return;
 355
 356     m_webFrame->page()->d->updateNavigationActions();
 357 }
 358
 359
 360 void FrameLoaderClientQt::dispatchDidFinishLoad()
 361 {
 362     if (dumpFrameLoaderCallbacks)
 363         printf("%s - didFinishLoadForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 364
 365     if (m_webFrame)
 366         emit m_webFrame->loadDone(true);
 367     if (m_frame->tree()->parent() || !m_webFrame)
 368         return;
 369     m_webFrame->page()->d->updateNavigationActions();
 370 }
 371
 372
 373 void FrameLoaderClientQt::dispatchDidFirstLayout()
 374 {
 375     if (m_webFrame)
 376         emit m_webFrame->initialLayoutComplete();
 377 }
 378
 379
 380 void FrameLoaderClientQt::dispatchShow()
 381 {
 382     notImplemented();
 383 }
 384
 385
 386 void FrameLoaderClientQt::cancelPolicyCheck()
 387 {
 388 //    qDebug() << "FrameLoaderClientQt::cancelPolicyCheck";
 389     m_policyFunction = 0;
 390 }
 391
 392
 393 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
 394                                                  PassRefPtr<FormState>)
 395 {
 396     notImplemented();
 397     Q_ASSERT(!m_policyFunction);
 398     // FIXME: This is surely too simple
 399     callPolicyFunction(function, PolicyUse);
 400 }
 401
 402
 403 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
 404 {
 405 }
 406
 407
 408 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
 409 {
 410     notImplemented();
 411 }
 412
 413
 414 void FrameLoaderClientQt::postProgressStartedNotification()
 415 {
 416     if (m_webFrame && m_frame->page())
 417         emit loadStarted();
 418     if (m_frame->tree()->parent() || !m_webFrame)
 419         return;
 420     m_webFrame->page()->d->updateNavigationActions();
 421 }
 422
 423 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
 424 {
 425     if (m_webFrame && m_frame->page())
 426         emit loadProgressChanged(qRound(m_frame->page()->progress()->estimatedProgress() * 100));
 427 }
 428
 429 void FrameLoaderClientQt::postProgressFinishedNotification()
 430 {
 431     if (m_webFrame && m_frame->page())
 432         emit loadFinished();
 433 }
 434
 435 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
 436 {
 437     // this is only interesting once we provide an external API for the DOM
 438 }
 439
 440
 441 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
 442 {
 443     // no need for, dispatchDidReceiveTitle is the right callback
 444 }
 445
 446
 447 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *)
 448 {
 449     // no need for, dispatchDidReceiveTitle is the right callback
 450 }
 451
 452
 453 void FrameLoaderClientQt::finishedLoading(DocumentLoader* loader)
 454 {
 455     if (m_firstData) {
 456         FrameLoader *fl = loader->frameLoader();
 457         fl->setEncoding(m_response.textEncodingName(), false);
 458         m_firstData = false;
 459     }
 460 }
 461
 462
 463 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
 464 {
 465     if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType))
 466         return true;
 467
 468     if (MIMETypeRegistry::isSupportedNonImageMIMEType(MIMEType))
 469         return true;
 470
 471     return false;
 472 }
 473
 474 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
 475 {
 476     return false;
 477 }
 478
 479
 480 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
 481 {
 482     notImplemented();
 483     return String();
 484 }
 485
 486
 487 void FrameLoaderClientQt::frameLoadCompleted()
 488 {
 489     // Note: Can be called multiple times.
 490     // Even if already complete, we might have set a previous item on a frame that
 491     // didn't do any data loading on the past transaction. Make sure to clear these out.
 492     m_frame->loader()->setPreviousHistoryItem(0);
 493 }
 494
 495
 496 void FrameLoaderClientQt::restoreViewState()
 497 {
 498     notImplemented();
 499 }
 500
 501
 502 void FrameLoaderClientQt::provisionalLoadStarted()
 503 {
 504     // don't need to do anything here
 505 }
 506
 507
 508 void FrameLoaderClientQt::didFinishLoad()
 509 {
 510 //     notImplemented();
 511 }
 512
 513
 514 void FrameLoaderClientQt::prepareForDataSourceReplacement()
 515 {
 516     m_frame->loader()->detachChildren();
 517 }
 518
 519 void FrameLoaderClientQt::setTitle(const String&, const KURL&)
 520 {
 521     // no need for, dispatchDidReceiveTitle is the right callback
 522 }
 523
 524
 525 String FrameLoaderClientQt::userAgent(const KURL& url)
 526 {
 527     if (m_webFrame) {
 528         return m_webFrame->page()->userAgentFor(QUrl((QString)url.string()));
 529     }
 530     return String();
 531 }
 532
 533 void FrameLoaderClientQt::dispatchDidReceiveIcon()
 534 {
 535     if (dumpFrameLoaderCallbacks)
 536         printf("%s - didReceiveIconForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 537
 538     if (m_webFrame) {
 539         emit m_webFrame->iconLoaded();
 540     }
 541 }
 542
 543 void FrameLoaderClientQt::frameLoaderDestroyed()
 544 {
 545     delete m_webFrame;
 546     m_frame = 0;
 547     m_webFrame = 0;
 548
 549     delete this;
 550 }
 551
 552 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
 553 {
 554     return true;
 555 }
 556
 557 void FrameLoaderClientQt::windowObjectCleared()
 558 {
 559     if (dumpFrameLoaderCallbacks)
 560         printf("%s - didClearWindowObjectForFrame\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 561
 562     if (m_webFrame)
 563         emit m_webFrame->cleared();
 564 }
 565
 566 void FrameLoaderClientQt::didPerformFirstNavigation() const
 567 {
 568     if (m_frame->tree()->parent() || !m_webFrame)
 569         return;
 570     m_webFrame->page()->d->updateNavigationActions();
 571 }
 572
 573 void FrameLoaderClientQt::registerForIconNotification(bool)
 574 {
 575     notImplemented();
 576 }
 577
 578 void FrameLoaderClientQt::updateGlobalHistory(const WebCore::KURL& url)
 579 {
 580     QWebHistoryInterface *history = QWebHistoryInterface::defaultInterface();
 581     if (history)
 582         history->addHistoryEntry(url.prettyURL());
 583 }
 584
 585 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
 586 {
 587     return true;
 588 }
 589
 590 void FrameLoaderClientQt::saveViewStateToItem(WebCore::HistoryItem*)
 591 {
 592 }
 593
 594 bool FrameLoaderClientQt::canCachePage() const
 595 {
 596     return true;
 597 }
 598
 599 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError& error)
 600 {
 601     if (m_firstData) {
 602         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
 603         m_firstData = false;
 604     }
 605 }
 606
 607 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
 608 {
 609     if (!m_frame)
 610         return;
 611     FrameLoader *fl = loader->frameLoader();
 612     if (m_firstData) {
 613         fl->setEncoding(m_response.textEncodingName(), false);
 614         m_firstData = false;
 615     }
 616     fl->addData(data, length);
 617 }
 618
 619 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest& request)
 620 {
 621     return ResourceError("Error", -999, request.url().prettyURL(),
 622             QCoreApplication::translate("QWebFrame", "Request cancelled", 0, QCoreApplication::UnicodeUTF8));
 623 }
 624
 625 // copied from WebKit/Misc/WebKitErrors[Private].h
 626 enum {
 627     WebKitErrorCannotShowMIMEType =                             100,
 628     WebKitErrorCannotShowURL =                                  101,
 629     WebKitErrorFrameLoadInterruptedByPolicyChange =             102,
 630     WebKitErrorCannotUseRestrictedPort = 103,
 631     WebKitErrorCannotFindPlugIn =                               200,
 632     WebKitErrorCannotLoadPlugIn =                               201,
 633     WebKitErrorJavaUnavailable =                                202,
 634 };
 635
 636 WebCore::ResourceError FrameLoaderClientQt::blockedError(const WebCore::ResourceRequest& request)
 637 {
 638     return ResourceError("Error", WebKitErrorCannotUseRestrictedPort, request.url().prettyURL(),
 639             QCoreApplication::translate("QWebFrame", "Request blocked", 0, QCoreApplication::UnicodeUTF8));
 640 }
 641
 642
 643 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest& request)
 644 {
 645     return ResourceError("Error", WebKitErrorCannotShowURL, request.url().string(),
 646             QCoreApplication::translate("QWebFrame", "Cannot show URL", 0, QCoreApplication::UnicodeUTF8));
 647 }
 648
 649 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
 650 {
 651     return ResourceError("Error", WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(),
 652             QCoreApplication::translate("QWebFrame", "Frame load interruped by policy change", 0, QCoreApplication::UnicodeUTF8));
 653 }
 654
 655 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
 656 {
 657     return ResourceError("Error", WebKitErrorCannotShowMIMEType, response.url().string(),
 658             QCoreApplication::translate("QWebFrame", "Cannot show mimetype", 0, QCoreApplication::UnicodeUTF8));
 659 }
 660
 661 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse& response)
 662 {
 663     return ResourceError("Error", -998 /* ### */, response.url().string(),
 664             QCoreApplication::translate("QWebFrame", "File does not exist", 0, QCoreApplication::UnicodeUTF8));
 665 }
 666
 667 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
 668 {
 669     notImplemented();
 670     return false;
 671 }
 672
 673 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
 674 {
 675     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
 676     return loader.release();
 677 }
 678
 679 void FrameLoaderClientQt::download(WebCore::ResourceHandle* handle, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
 680 {
 681 #if QT_VERSION >= 0x040400
 682     if (!m_webFrame)
 683         return;
 684
 685     QNetworkReplyHandler* handler = handle->getInternal()->m_job;
 686     QNetworkReply* reply = handler->release();
 687     if (reply) {
 688         QWebPage *page = m_webFrame->page();
 689         if (page->receivers(SIGNAL(handleUnsupportedContent(QNetworkReply *))))
 690             emit m_webFrame->page()->handleUnsupportedContent(reply);
 691         else
 692             reply->abort();
 693     }
 694 #endif
 695 }
 696
 697 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
 698 {
 699 }
 700
 701 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
 702 {
 703     // seems like the Mac code doesn't do anything here by default neither
 704     //qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().string`();
 705 }
 706
 707 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
 708 {
 709     notImplemented();
 710 }
 711
 712 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
 713 {
 714     notImplemented();
 715 }
 716
 717 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
 718 {
 719
 720     m_response = response;
 721     m_firstData = true;
 722     //qDebug() << "    got response from" << response.url().string();
 723 }
 724
 725 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
 726 {
 727 }
 728
 729 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
 730 {
 731 }
 732
 733 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
 734 {
 735     if (m_firstData) {
 736         FrameLoader *fl = loader->frameLoader();
 737         fl->setEncoding(m_response.textEncodingName(), false);
 738         m_firstData = false;
 739     }
 740 }
 741
 742 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
 743 {
 744     notImplemented();
 745     return false;
 746 }
 747
 748 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
 749 {
 750     if (dumpFrameLoaderCallbacks)
 751         printf("%s - didFailProvisionalLoadWithError\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 752
 753     if (m_webFrame)
 754         emit m_webFrame->loadDone(false);
 755 }
 756
 757 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
 758 {
 759     if (dumpFrameLoaderCallbacks)
 760         printf("%s - didFailLoadWithError\n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)));
 761
 762     if (m_webFrame)
 763         emit m_webFrame->loadDone(false);
 764 }
 765
 766 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
 767 {
 768     if (!m_webFrame)
 769         return 0;
 770     QWebPage *newPage = m_webFrame->page()->createWindow();
 771     if (!newPage)
 772         return 0;
 773     return newPage->mainFrame()->d->frame;
 774 }
 775
 776 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String& MIMEType, const WebCore::ResourceRequest&)
 777 {
 778     // we need to call directly here
 779     Q_ASSERT(!m_policyFunction);
 780     m_policyFunction = function;
 781     if (canShowMIMEType(MIMEType))
 782         slotCallPolicyFunction(PolicyUse);
 783     else
 784         slotCallPolicyFunction(PolicyDownload);
 785 }
 786
 787 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
 788 {
 789     Q_ASSERT(!m_policyFunction);
 790     m_policyFunction = function;
 791     slotCallPolicyFunction(PolicyUse);
 792 }
 793
 794 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request)
 795 {
 796     Q_ASSERT(!m_policyFunction);
 797     m_policyFunction = function;
 798     if (m_webFrame) {
 799 #if QT_VERSION < 0x040400
 800         QWebNetworkRequest r(request);
 801 #else
 802         QNetworkRequest r(request.toNetworkRequest());
 803 #endif
 804         QWebPage *page = m_webFrame->page();
 805
 806         if (page->d->navigationRequested(m_webFrame, r, QWebPage::NavigationType(action.type())) ==
 807             QWebPage::IgnoreNavigationRequest) {
 808             slotCallPolicyFunction(PolicyIgnore);
 809             return;
 810         }
 811     }
 812     slotCallPolicyFunction(PolicyUse);
 813     return;
 814 }
 815
 816 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
 817 {
 818     notImplemented();
 819 }
 820
 821 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest& request)
 822 {
 823 #if QT_VERSION >= 0x040400
 824     if (!m_webFrame)
 825         return;
 826
 827     QWebPage *page = m_webFrame->page();
 828     emit m_webFrame->page()->download(request.toNetworkRequest());
 829 #endif
 830 }
 831
 832 PassRefPtr<Frame> FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
 833                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
 834 {
 835     if (!m_webFrame)
 836         return 0;
 837
 838     QWebFrameData frameData;
 839     frameData.url = url;
 840     frameData.name = name;
 841     frameData.ownerElement = ownerElement;
 842     frameData.referrer = referrer;
 843     frameData.allowsScrolling = allowsScrolling;
 844     frameData.marginWidth = marginWidth;
 845     frameData.marginHeight = marginHeight;
 846
 847     QWebFrame* webFrame = new QWebFrame(m_webFrame, &frameData);
 848     emit m_webFrame->page()->frameCreated(webFrame);
 849
 850     RefPtr<Frame> childFrame = adoptRef(webFrame->d->frame);
 851
 852     // FIXME: All of the below should probably be moved over into WebCore
 853     childFrame->tree()->setName(name);
 854     m_frame->tree()->appendChild(childFrame);
 855     // ### set override encoding if we have one
 856
 857     FrameLoadType loadType = m_frame->loader()->loadType();
 858     FrameLoadType childLoadType = FrameLoadTypeRedirectWithLockedHistory;
 859
 860     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
 861                              String(), 0, 0);
 862
 863     // The frame's onload handler may have removed it from the document.
 864     if (!childFrame->tree()->parent())
 865         return 0;
 866
 867     return childFrame.release();
 868 }
 869
 870 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& _mimeType)
 871 {
 872 //    qDebug()<<" ++++++++++++++++ url is "<<url.prettyURL()<<", mime = "<<_mimeType;
 873     if (_mimeType == "application/x-qt-plugin" || _mimeType == "application/x-qt-styled-widget")
 874         return ObjectContentOtherPlugin;
 875
 876     if (url.isEmpty())
 877         return ObjectContentNone;
 878
 879     String mimeType = _mimeType;
 880     if (!mimeType.length()) {
 881         QFileInfo fi(url.path());
 882         mimeType = MIMETypeRegistry::getMIMETypeForExtension(fi.suffix());
 883     }
 884
 885     if (!mimeType.length())
 886         return ObjectContentFrame;
 887
 888     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
 889         return ObjectContentImage;
 890
 891     if (m_frame->page() && m_frame->page()->pluginData()->supportsMimeType(mimeType))
 892         return ObjectContentOtherPlugin;
 893
 894     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
 895         return ObjectContentFrame;
 896
 897     if (url.protocol() == "about")
 898         return ObjectContentFrame;
 899
 900     return ObjectContentNone;
 901 }
 902
 903 static const CSSPropertyID qstyleSheetProperties[] = {
 904     CSSPropertyColor,
 905     CSSPropertyFontFamily,
 906     CSSPropertyFontSize,
 907     CSSPropertyFontStyle,
 908     CSSPropertyFontWeight
 909 };
 910
 911 const unsigned numqStyleSheetProperties = sizeof(qstyleSheetProperties) / sizeof(qstyleSheetProperties[0]);
 912
 913 Widget* FrameLoaderClientQt::createPlugin(const IntSize&, Element* element, const KURL& url, const Vector<String>& paramNames,
 914                                           const Vector<String>& paramValues, const String& mimeType, bool loadManually)
 915 {
 916 //     qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.prettyURL() << mimeType;
 917 //     qDebug()<<"------\t url = "<<url.prettyURL();
 918
 919     if (!m_webFrame)
 920         return 0;
 921
 922     QStringList params;
 923     QStringList values;
 924     for (int i = 0; i < paramNames.size(); ++i)
 925         params.append(paramNames[i]);
 926     for (int i = 0; i < paramValues.size(); ++i)
 927         values.append(paramValues[i]);
 928
 929     QString urlStr(url.string());
 930     QUrl qurl = urlStr;
 931
 932     QObject *object = 0;
 933
 934     if (mimeType == "application/x-qt-plugin" || mimeType == "application/x-qt-styled-widget") {
 935         object = m_webFrame->page()->createPlugin(element->getAttribute("classid"), qurl, params, values);
 936         QWidget *widget = qobject_cast<QWidget *>(object);
 937         if (widget && mimeType == "application/x-qt-styled-widget") {
 938             CSSComputedStyleDeclaration cssDecl(element);
 939
 940             QString styleSheet = element->getAttribute("style");
 941             if (!styleSheet.isEmpty())
 942                 styleSheet += QLatin1Char(';');
 943
 944             for (int i = 0; i < numqStyleSheetProperties; ++i) {
 945                 CSSPropertyID property = qstyleSheetProperties[i];
 946
 947                 styleSheet += ::getPropertyName(property);
 948                 styleSheet += QLatin1Char(':');
 949                 styleSheet += cssDecl.getPropertyValue(property);
 950                 styleSheet += QLatin1Char(';');
 951             }
 952
 953             widget->setStyleSheet(styleSheet);
 954         }
 955     }
 956
 957 #if QT_VERSION >= 0x040400
 958     if (!object) {
 959         QWebPluginFactory* factory = m_webFrame->page()->pluginFactory();
 960         if (factory)
 961             object = factory->create(mimeType, qurl, params, values);
 962     }
 963 #endif
 964
 965     if (object) {
 966         QWidget *widget = qobject_cast<QWidget *>(object);
 967         QWidget *view = m_webFrame->page()->view();
 968         if (widget && view) {
 969             widget->setParent(view);
 970             Widget* w= new Widget();
 971             w->setNativeWidget(widget);
 972             return w;
 973         }
 974         // FIXME: make things work for widgetless plugins as well
 975         delete object;
 976     }
 977
 978     return 0;
 979 }
 980
 981 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
 982 {
 983     notImplemented();
 984     return;
 985 }
 986
 987 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
 988                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
 989 {
 990     notImplemented();
 991     return 0;
 992 }
 993
 994 String FrameLoaderClientQt::overrideMediaType() const
 995 {
 996     return String();
 997 }
 998
 999 QString FrameLoaderClientQt::chooseFile(const QString& oldFile)
1000 {
1001     return webFrame()->page()->chooseFile(webFrame(), oldFile);
1002 }
1003
1004
1005 }
1006
1007 #include "moc_FrameLoaderClientQt.cpp"