WebKit/wince/WebCoreSupport/FrameLoaderClientWinCE.cpp

   1 /*
   2  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
   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 AND ITS CONTRIBUTORS "AS IS" AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  20  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "config.h"
  26 #include "FrameLoaderClientWinCE.h"
  27
  28 #include "DocumentLoader.h"
  29 #include "FrameLoader.h"
  30 #include "FrameNetworkingContextWinCE.h"
  31 #include "FrameView.h"
  32 #include "HTMLFormElement.h"
  33 #include "MIMETypeRegistry.h"
  34 #include "NotImplemented.h"
  35 #include "Page.h"
  36 #include "PluginDatabase.h"
  37 #include "RenderPart.h"
  38 #include "WebView.h"
  39
  40 using namespace WebCore;
  41
  42 namespace WebKit {
  43
  44 FrameLoaderClientWinCE::FrameLoaderClientWinCE(WebView* view)
  45     : m_webView(view)
  46     , m_pluginView(0)
  47 {
  48     ASSERT(m_webView);
  49 }
  50
  51 FrameLoaderClientWinCE::~FrameLoaderClientWinCE()
  52 {
  53 }
  54
  55 String FrameLoaderClientWinCE::userAgent(const KURL&)
  56 {
  57     return "WebKitWinCE";
  58 }
  59
  60 PassRefPtr<DocumentLoader> FrameLoaderClientWinCE::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
  61 {
  62     return DocumentLoader::create(request, substituteData);
  63 }
  64
  65 void FrameLoaderClientWinCE::committedLoad(DocumentLoader* loader, const char* data, int length)
  66 {
  67     if (m_pluginView) {
  68         if (!m_hasSentResponseToPlugin) {
  69             m_pluginView->didReceiveResponse(loader->response());
  70             m_hasSentResponseToPlugin = true;
  71         }
  72         m_pluginView->didReceiveData(data, length);
  73     } else
  74         loader->commitData(data, length);
  75 }
  76
  77 bool FrameLoaderClientWinCE::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
  78 {
  79     notImplemented();
  80     return false;
  81 }
  82
  83 void FrameLoaderClientWinCE::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
  84 {
  85     notImplemented();
  86 }
  87
  88 void FrameLoaderClientWinCE::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
  89 {
  90     notImplemented();
  91 }
  92
  93 void FrameLoaderClientWinCE::dispatchWillSendRequest(DocumentLoader*, unsigned long, WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
  94 {
  95     notImplemented();
  96 }
  97
  98 void FrameLoaderClientWinCE::assignIdentifierToInitialRequest(unsigned long, DocumentLoader*, const WebCore::ResourceRequest&)
  99 {
 100     notImplemented();
 101 }
 102
 103 void FrameLoaderClientWinCE::postProgressStartedNotification()
 104 {
 105     notImplemented();
 106 }
 107
 108 void FrameLoaderClientWinCE::postProgressEstimateChangedNotification()
 109 {
 110     notImplemented();
 111 }
 112
 113 void FrameLoaderClientWinCE::postProgressFinishedNotification()
 114 {
 115     notImplemented();
 116 }
 117
 118 void FrameLoaderClientWinCE::frameLoaderDestroyed()
 119 {
 120     m_webView = 0;
 121     m_frame = 0;
 122     delete this;
 123 }
 124
 125 void FrameLoaderClientWinCE::dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse& response)
 126 {
 127     m_response = response;
 128 }
 129
 130 void FrameLoaderClientWinCE::dispatchDecidePolicyForMIMEType(FramePolicyFunction policyFunction, const String& mimeType, const WebCore::ResourceRequest&)
 131 {
 132     if (canShowMIMEType(mimeType))
 133         (m_frame->loader()->policyChecker()->*policyFunction)(PolicyUse);
 134     else
 135         (m_frame->loader()->policyChecker()->*policyFunction)(PolicyDownload);
 136 }
 137
 138 void FrameLoaderClientWinCE::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction policyFunction, const NavigationAction&, const WebCore::ResourceRequest&, PassRefPtr<FormState>, const String&)
 139 {
 140     (m_frame->loader()->policyChecker()->*policyFunction)(PolicyUse);
 141 }
 142
 143 void FrameLoaderClientWinCE::dispatchDecidePolicyForNavigationAction(FramePolicyFunction policyFunction, const NavigationAction&, const WebCore::ResourceRequest&, PassRefPtr<FormState>)
 144 {
 145     (m_frame->loader()->policyChecker()->*policyFunction)(PolicyUse);
 146 }
 147
 148 void FrameLoaderClientWinCE::dispatchWillSubmitForm(FramePolicyFunction policyFunction, PassRefPtr<FormState>)
 149 {
 150     (m_frame->loader()->policyChecker()->*policyFunction)(PolicyUse);
 151 }
 152
 153 PassRefPtr<Widget> FrameLoaderClientWinCE::createPlugin(const IntSize&, HTMLPlugInElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool)
 154 {
 155     return 0;
 156 }
 157
 158 PassRefPtr<Frame> FrameLoaderClientWinCE::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
 159                                                  const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
 160 {
 161     return m_webView->createFrame(url, name, ownerElement, referrer, allowsScrolling, marginWidth, marginHeight);
 162 }
 163
 164 void FrameLoaderClientWinCE::didTransferChildFrameToNewDocument(Page*)
 165 {
 166 }
 167
 168 void FrameLoaderClientWinCE::transferLoadingResourceFromPage(unsigned long, DocumentLoader*, const WebCore::ResourceRequest&, Page*)
 169 {
 170 }
 171
 172 void FrameLoaderClientWinCE::redirectDataToPlugin(Widget* pluginWidget)
 173 {
 174     ASSERT(!m_pluginView);
 175     m_pluginView = static_cast<PluginView*>(pluginWidget);
 176     m_hasSentResponseToPlugin = false;
 177 }
 178
 179 PassRefPtr<Widget> FrameLoaderClientWinCE::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL&, const Vector<String>&, const Vector<String>&)
 180 {
 181     notImplemented();
 182     return 0;
 183 }
 184
 185 ObjectContentType FrameLoaderClientWinCE::objectContentType(const KURL& url, const String& mimeType)
 186 {
 187     return FrameLoader::defaultObjectContentType(url, mimeType);
 188 }
 189
 190 String FrameLoaderClientWinCE::overrideMediaType() const
 191 {
 192     notImplemented();
 193     return String();
 194 }
 195
 196 void FrameLoaderClientWinCE::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*)
 197 {
 198     notImplemented();
 199 }
 200
 201 void FrameLoaderClientWinCE::documentElementAvailable()
 202 {
 203     notImplemented();
 204 }
 205
 206 void FrameLoaderClientWinCE::didPerformFirstNavigation() const
 207 {
 208     notImplemented();
 209 }
 210
 211 void FrameLoaderClientWinCE::registerForIconNotification(bool)
 212 {
 213     notImplemented();
 214 }
 215
 216 void FrameLoaderClientWinCE::setMainFrameDocumentReady(bool)
 217 {
 218     notImplemented();
 219 }
 220
 221 bool FrameLoaderClientWinCE::hasWebView() const
 222 {
 223     return true;
 224 }
 225
 226 void FrameLoaderClientWinCE::dispatchDidFinishLoad()
 227 {
 228     notImplemented();
 229 }
 230
 231 void FrameLoaderClientWinCE::frameLoadCompleted()
 232 {
 233     notImplemented();
 234 }
 235
 236 void FrameLoaderClientWinCE::saveViewStateToItem(HistoryItem*)
 237 {
 238     notImplemented();
 239 }
 240
 241 void FrameLoaderClientWinCE::restoreViewState()
 242 {
 243     notImplemented();
 244 }
 245
 246 bool FrameLoaderClientWinCE::shouldGoToHistoryItem(HistoryItem* item) const
 247 {
 248     return item;
 249 }
 250
 251 void FrameLoaderClientWinCE::dispatchDidAddBackForwardItem(HistoryItem*) const
 252 {
 253 }
 254
 255 void FrameLoaderClientWinCE::dispatchDidRemoveBackForwardItem(HistoryItem*) const
 256 {
 257 }
 258
 259 void FrameLoaderClientWinCE::dispatchDidChangeBackForwardIndex() const
 260 {
 261 }
 262
 263 void FrameLoaderClientWinCE::didDisplayInsecureContent()
 264 {
 265     notImplemented();
 266 }
 267
 268 void FrameLoaderClientWinCE::didRunInsecureContent(SecurityOrigin*)
 269 {
 270     notImplemented();
 271 }
 272
 273 void FrameLoaderClientWinCE::makeRepresentation(DocumentLoader*)
 274 {
 275     notImplemented();
 276 }
 277
 278 void FrameLoaderClientWinCE::forceLayout()
 279 {
 280     notImplemented();
 281 }
 282
 283 void FrameLoaderClientWinCE::forceLayoutForNonHTML()
 284 {
 285     notImplemented();
 286 }
 287
 288 void FrameLoaderClientWinCE::setCopiesOnScroll()
 289 {
 290     notImplemented();
 291 }
 292
 293 void FrameLoaderClientWinCE::detachedFromParent2()
 294 {
 295     notImplemented();
 296 }
 297
 298 void FrameLoaderClientWinCE::detachedFromParent3()
 299 {
 300     notImplemented();
 301 }
 302
 303 void FrameLoaderClientWinCE::dispatchDidHandleOnloadEvents()
 304 {
 305     notImplemented();
 306 }
 307
 308 void FrameLoaderClientWinCE::dispatchDidReceiveServerRedirectForProvisionalLoad()
 309 {
 310     notImplemented();
 311 }
 312
 313 void FrameLoaderClientWinCE::dispatchDidCancelClientRedirect()
 314 {
 315     notImplemented();
 316 }
 317
 318 void FrameLoaderClientWinCE::dispatchWillPerformClientRedirect(const KURL&, double, double)
 319 {
 320     notImplemented();
 321 }
 322
 323 void FrameLoaderClientWinCE::dispatchDidChangeLocationWithinPage()
 324 {
 325     notImplemented();
 326 }
 327
 328 void FrameLoaderClientWinCE::dispatchDidPushStateWithinPage()
 329 {
 330     notImplemented();
 331 }
 332
 333 void FrameLoaderClientWinCE::dispatchDidReplaceStateWithinPage()
 334 {
 335     notImplemented();
 336 }
 337
 338 void FrameLoaderClientWinCE::dispatchDidPopStateWithinPage()
 339 {
 340     notImplemented();
 341 }
 342
 343 void FrameLoaderClientWinCE::dispatchWillClose()
 344 {
 345     notImplemented();
 346 }
 347
 348 void FrameLoaderClientWinCE::dispatchDidReceiveIcon()
 349 {
 350     notImplemented();
 351 }
 352
 353 void FrameLoaderClientWinCE::dispatchDidStartProvisionalLoad()
 354 {
 355     notImplemented();
 356 }
 357
 358 void FrameLoaderClientWinCE::dispatchDidReceiveTitle(const String&)
 359 {
 360     notImplemented();
 361 }
 362
 363 void FrameLoaderClientWinCE::dispatchDidChangeIcons()
 364 {
 365     notImplemented();
 366 }
 367
 368 void FrameLoaderClientWinCE::dispatchDidCommitLoad()
 369 {
 370     notImplemented();
 371 }
 372
 373 void FrameLoaderClientWinCE::dispatchDidFinishDocumentLoad()
 374 {
 375     notImplemented();
 376 }
 377
 378 void FrameLoaderClientWinCE::dispatchDidFirstLayout()
 379 {
 380     notImplemented();
 381 }
 382
 383 void FrameLoaderClientWinCE::dispatchDidFirstVisuallyNonEmptyLayout()
 384 {
 385     notImplemented();
 386 }
 387
 388 void FrameLoaderClientWinCE::dispatchShow()
 389 {
 390     notImplemented();
 391 }
 392
 393 void FrameLoaderClientWinCE::cancelPolicyCheck()
 394 {
 395     notImplemented();
 396 }
 397
 398 void FrameLoaderClientWinCE::dispatchDidLoadMainResource(DocumentLoader*)
 399 {
 400     notImplemented();
 401 }
 402
 403 void FrameLoaderClientWinCE::revertToProvisionalState(DocumentLoader*)
 404 {
 405     notImplemented();
 406 }
 407
 408 void FrameLoaderClientWinCE::willChangeTitle(DocumentLoader*)
 409 {
 410     notImplemented();
 411 }
 412
 413 void FrameLoaderClientWinCE::didChangeTitle(DocumentLoader* documentLoader)
 414 {
 415     setTitle(documentLoader->title(), documentLoader->url());
 416 }
 417
 418 bool FrameLoaderClientWinCE::canHandleRequest(const WebCore::ResourceRequest&) const
 419 {
 420     notImplemented();
 421     return true;
 422 }
 423
 424 bool FrameLoaderClientWinCE::canShowMIMEType(const String& type) const
 425 {
 426     return (MIMETypeRegistry::isSupportedImageMIMEType(type)
 427             || MIMETypeRegistry::isSupportedNonImageMIMEType(type)
 428             || MIMETypeRegistry::isSupportedMediaMIMEType(type)
 429             || PluginDatabase::installedPlugins()->isMIMETypeRegistered(type));
 430 }
 431
 432 bool FrameLoaderClientWinCE::canShowMIMETypeAsHTML(const String&) const
 433 {
 434     notImplemented();
 435     return false;
 436 }
 437
 438 bool FrameLoaderClientWinCE::representationExistsForURLScheme(const String&) const
 439 {
 440     notImplemented();
 441     return false;
 442 }
 443
 444 String FrameLoaderClientWinCE::generatedMIMETypeForURLScheme(const String&) const
 445 {
 446     notImplemented();
 447     return String();
 448 }
 449
 450 void FrameLoaderClientWinCE::finishedLoading(DocumentLoader* documentLoader)
 451 {
 452     if (!m_pluginView) {
 453         FrameLoader* loader = documentLoader->frameLoader();
 454         loader->writer()->setEncoding(m_response.textEncodingName(), false);
 455         return;
 456     }
 457
 458     m_pluginView->didFinishLoading();
 459     m_pluginView = 0;
 460     m_hasSentResponseToPlugin = false;
 461 }
 462
 463 void FrameLoaderClientWinCE::provisionalLoadStarted()
 464 {
 465     notImplemented();
 466 }
 467
 468 void FrameLoaderClientWinCE::didFinishLoad()
 469 {
 470     notImplemented();
 471 }
 472
 473 void FrameLoaderClientWinCE::prepareForDataSourceReplacement()
 474 {
 475     notImplemented();
 476 }
 477
 478 void FrameLoaderClientWinCE::setTitle(const String&, const KURL&)
 479 {
 480     notImplemented();
 481 }
 482
 483 void FrameLoaderClientWinCE::dispatchDidReceiveContentLength(DocumentLoader*, unsigned long, int)
 484 {
 485     notImplemented();
 486 }
 487
 488 void FrameLoaderClientWinCE::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
 489 {
 490     notImplemented();
 491 }
 492
 493 void FrameLoaderClientWinCE::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
 494 {
 495     notImplemented();
 496 }
 497
 498 bool FrameLoaderClientWinCE::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
 499 {
 500     notImplemented();
 501     return false;
 502 }
 503
 504 void FrameLoaderClientWinCE::dispatchDidFailProvisionalLoad(const ResourceError& error)
 505 {
 506     dispatchDidFailLoad(error);
 507 }
 508
 509 void FrameLoaderClientWinCE::dispatchDidFailLoad(const ResourceError&)
 510 {
 511     notImplemented();
 512 }
 513
 514 void FrameLoaderClientWinCE::download(ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
 515 {
 516     notImplemented();
 517 }
 518
 519 ResourceError FrameLoaderClientWinCE::cancelledError(const WebCore::ResourceRequest&)
 520 {
 521     return ResourceError();
 522 }
 523
 524 ResourceError FrameLoaderClientWinCE::blockedError(const WebCore::ResourceRequest&)
 525 {
 526     return ResourceError();
 527 }
 528
 529 ResourceError FrameLoaderClientWinCE::cannotShowURLError(const WebCore::ResourceRequest&)
 530 {
 531     return ResourceError();
 532 }
 533
 534 ResourceError FrameLoaderClientWinCE::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
 535 {
 536     return ResourceError();
 537 }
 538
 539 ResourceError FrameLoaderClientWinCE::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
 540 {
 541     return ResourceError();
 542 }
 543
 544 ResourceError FrameLoaderClientWinCE::fileDoesNotExistError(const WebCore::ResourceResponse&)
 545 {
 546     return ResourceError();
 547 }
 548
 549 ResourceError FrameLoaderClientWinCE::pluginWillHandleLoadError(const WebCore::ResourceResponse&)
 550 {
 551     return ResourceError();
 552 }
 553
 554 bool FrameLoaderClientWinCE::shouldFallBack(const ResourceError& error)
 555 {
 556     return !(error.isCancellation());
 557 }
 558
 559 bool FrameLoaderClientWinCE::canCachePage() const
 560 {
 561     return true;
 562 }
 563
 564 Frame* FrameLoaderClientWinCE::dispatchCreatePage(const NavigationAction&)
 565 {
 566     notImplemented();
 567     return 0;
 568 }
 569
 570 void FrameLoaderClientWinCE::dispatchUnableToImplementPolicy(const ResourceError&)
 571 {
 572     notImplemented();
 573 }
 574
 575 void FrameLoaderClientWinCE::setMainDocumentError(DocumentLoader*, const ResourceError& error)
 576 {
 577     if (!m_pluginView)
 578         return;
 579
 580     m_pluginView->didFail(error);
 581     m_pluginView = 0;
 582     m_hasSentResponseToPlugin = false;
 583 }
 584
 585 void FrameLoaderClientWinCE::startDownload(const WebCore::ResourceRequest&)
 586 {
 587     notImplemented();
 588 }
 589
 590 void FrameLoaderClientWinCE::updateGlobalHistory()
 591 {
 592     notImplemented();
 593 }
 594
 595 void FrameLoaderClientWinCE::updateGlobalHistoryRedirectLinks()
 596 {
 597     notImplemented();
 598 }
 599
 600 void FrameLoaderClientWinCE::savePlatformDataToCachedFrame(CachedFrame*)
 601 {
 602     notImplemented();
 603 }
 604
 605 void FrameLoaderClientWinCE::transitionToCommittedFromCachedFrame(CachedFrame*)
 606 {
 607     notImplemented();
 608 }
 609
 610 void FrameLoaderClientWinCE::transitionToCommittedForNewPage()
 611 {
 612     Page* page = m_frame->page();
 613     ASSERT(page);
 614
 615     bool isMainFrame = m_frame == page->mainFrame();
 616
 617     m_frame->setView(0);
 618
 619     RefPtr<FrameView> frameView;
 620     if (isMainFrame) {
 621         RECT rect;
 622         m_webView->frameRect(&rect);
 623         frameView = FrameView::create(m_frame, IntRect(rect).size());
 624     } else
 625         frameView = FrameView::create(m_frame);
 626
 627     m_frame->setView(frameView);
 628
 629     if (m_frame->ownerRenderer())
 630         m_frame->ownerRenderer()->setWidget(frameView);
 631 }
 632
 633 void FrameLoaderClientWinCE::dispatchDidBecomeFrameset(bool)
 634 {
 635 }
 636
 637 PassRefPtr<WebCore::FrameNetworkingContext> FrameLoaderClientWinCE::createNetworkingContext()
 638 {
 639     return FrameNetworkingContextWinCE::create(m_frame, userAgent(KURL()));
 640 }
 641
 642 } // namespace WebKit