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