src/third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp

   1 /*
   2  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
   3  * Copyright (C) 2011 Apple Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  *     * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *     * Neither the name of Google Inc. nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "config.h"
  33 #include "web/FrameLoaderClientImpl.h"
  34
  35 #include "bindings/core/v8/ScriptController.h"
  36 #include "core/HTMLNames.h"
  37 #include "core/dom/Document.h"
  38 #include "core/dom/Fullscreen.h"
  39 #include "core/events/MessageEvent.h"
  40 #include "core/events/MouseEvent.h"
  41 #include "core/frame/FrameView.h"
  42 #include "core/frame/Settings.h"
  43 #include "core/html/HTMLAppletElement.h"
  44 #include "core/loader/DocumentLoader.h"
  45 #include "core/loader/FrameLoadRequest.h"
  46 #include "core/loader/FrameLoader.h"
  47 #include "core/loader/HistoryItem.h"
  48 #include "core/page/Chrome.h"
  49 #include "core/page/EventHandler.h"
  50 #include "core/page/Page.h"
  51 #include "core/page/WindowFeatures.h"
  52 #include "core/rendering/HitTestResult.h"
  53 #include "modules/device_light/DeviceLightController.h"
  54 #include "modules/device_orientation/DeviceMotionController.h"
  55 #include "modules/device_orientation/DeviceOrientationController.h"
  56 #include "modules/gamepad/NavigatorGamepad.h"
  57 #include "modules/serviceworkers/NavigatorServiceWorker.h"
  58 #include "platform/MIMETypeRegistry.h"
  59 #include "platform/RuntimeEnabledFeatures.h"
  60 #include "platform/UserGestureIndicator.h"
  61 #include "platform/exported/WrappedResourceRequest.h"
  62 #include "platform/exported/WrappedResourceResponse.h"
  63 #include "platform/network/HTTPParsers.h"
  64 #include "platform/plugins/PluginData.h"
  65 #include "public/platform/Platform.h"
  66 #include "public/platform/WebApplicationCacheHost.h"
  67 #include "public/platform/WebMimeRegistry.h"
  68 #include "public/platform/WebRTCPeerConnectionHandler.h"
  69 #include "public/platform/WebServiceWorkerProvider.h"
  70 #include "public/platform/WebServiceWorkerProviderClient.h"
  71 #include "public/platform/WebURL.h"
  72 #include "public/platform/WebURLError.h"
  73 #include "public/platform/WebVector.h"
  74 #include "public/web/WebAutofillClient.h"
  75 #include "public/web/WebCachedURLRequest.h"
  76 #include "public/web/WebDOMEvent.h"
  77 #include "public/web/WebDocument.h"
  78 #include "public/web/WebFormElement.h"
  79 #include "public/web/WebFrameClient.h"
  80 #include "public/web/WebNode.h"
  81 #include "public/web/WebPermissionClient.h"
  82 #include "public/web/WebPlugin.h"
  83 #include "public/web/WebPluginParams.h"
  84 #include "public/web/WebPluginPlaceholder.h"
  85 #include "public/web/WebSecurityOrigin.h"
  86 #include "public/web/WebViewClient.h"
  87 #include "web/PluginPlaceholderImpl.h"
  88 #include "web/SharedWorkerRepositoryClientImpl.h"
  89 #include "web/WebDataSourceImpl.h"
  90 #include "web/WebDevToolsAgentPrivate.h"
  91 #include "web/WebLocalFrameImpl.h"
  92 #include "web/WebPluginContainerImpl.h"
  93 #include "web/WebPluginLoadObserver.h"
  94 #include "web/WebViewImpl.h"
  95 #include "wtf/StringExtras.h"
  96 #include "wtf/text/CString.h"
  97 #include "wtf/text/WTFString.h"
  98 #include <v8.h>
  99
 100 namespace blink {
 101
 102 FrameLoaderClientImpl::FrameLoaderClientImpl(WebLocalFrameImpl* frame)
 103     : m_webFrame(frame)
 104 {
 105 }
 106
 107 FrameLoaderClientImpl::~FrameLoaderClientImpl()
 108 {
 109 }
 110
 111 void FrameLoaderClientImpl::dispatchDidClearWindowObjectInMainWorld()
 112 {
 113     if (m_webFrame->client()) {
 114         m_webFrame->client()->didClearWindowObject(m_webFrame);
 115         Document* document = m_webFrame->frame()->document();
 116         if (document) {
 117             DeviceMotionController::from(*document);
 118             DeviceOrientationController::from(*document);
 119             if (RuntimeEnabledFeatures::deviceLightEnabled())
 120                 DeviceLightController::from(*document);
 121             NavigatorGamepad::from(*document);
 122             if (RuntimeEnabledFeatures::serviceWorkerEnabled())
 123                 NavigatorServiceWorker::from(*document);
 124         }
 125     }
 126 }
 127
 128 void FrameLoaderClientImpl::documentElementAvailable()
 129 {
 130     if (m_webFrame->client())
 131         m_webFrame->client()->didCreateDocumentElement(m_webFrame);
 132 }
 133
 134 void FrameLoaderClientImpl::didCreateScriptContext(v8::Handle<v8::Context> context, int extensionGroup, int worldId)
 135 {
 136     WebViewImpl* webview = m_webFrame->viewImpl();
 137     if (webview->devToolsAgentPrivate())
 138         webview->devToolsAgentPrivate()->didCreateScriptContext(m_webFrame, worldId);
 139     if (m_webFrame->client())
 140         m_webFrame->client()->didCreateScriptContext(m_webFrame, context, extensionGroup, worldId);
 141 }
 142
 143 void FrameLoaderClientImpl::willReleaseScriptContext(v8::Handle<v8::Context> context, int worldId)
 144 {
 145     if (m_webFrame->client())
 146         m_webFrame->client()->willReleaseScriptContext(m_webFrame, context, worldId);
 147 }
 148
 149 bool FrameLoaderClientImpl::allowScriptExtension(const String& extensionName,
 150                                                  int extensionGroup,
 151                                                  int worldId)
 152 {
 153     if (m_webFrame->permissionClient())
 154         return m_webFrame->permissionClient()->allowScriptExtension(extensionName, extensionGroup, worldId);
 155
 156     return true;
 157 }
 158
 159 void FrameLoaderClientImpl::didChangeScrollOffset()
 160 {
 161     if (m_webFrame->client())
 162         m_webFrame->client()->didChangeScrollOffset(m_webFrame);
 163 }
 164
 165 void FrameLoaderClientImpl::didUpdateCurrentHistoryItem()
 166 {
 167     if (m_webFrame->client())
 168         m_webFrame->client()->didUpdateCurrentHistoryItem(m_webFrame);
 169 }
 170
 171 void FrameLoaderClientImpl::didRemoveAllPendingStylesheet()
 172 {
 173     WebViewImpl* webview = m_webFrame->viewImpl();
 174     if (webview)
 175         webview->didRemoveAllPendingStylesheet(m_webFrame);
 176 }
 177
 178 bool FrameLoaderClientImpl::allowScript(bool enabledPerSettings)
 179 {
 180     if (m_webFrame->permissionClient())
 181         return m_webFrame->permissionClient()->allowScript(enabledPerSettings);
 182
 183     return enabledPerSettings;
 184 }
 185
 186 bool FrameLoaderClientImpl::allowScriptFromSource(bool enabledPerSettings, const KURL& scriptURL)
 187 {
 188     if (m_webFrame->permissionClient())
 189         return m_webFrame->permissionClient()->allowScriptFromSource(enabledPerSettings, scriptURL);
 190
 191     return enabledPerSettings;
 192 }
 193
 194 bool FrameLoaderClientImpl::allowPlugins(bool enabledPerSettings)
 195 {
 196     if (m_webFrame->permissionClient())
 197         return m_webFrame->permissionClient()->allowPlugins(enabledPerSettings);
 198
 199     return enabledPerSettings;
 200 }
 201
 202 bool FrameLoaderClientImpl::allowImage(bool enabledPerSettings, const KURL& imageURL)
 203 {
 204     if (m_webFrame->permissionClient())
 205         return m_webFrame->permissionClient()->allowImage(enabledPerSettings, imageURL);
 206
 207     return enabledPerSettings;
 208 }
 209
 210 bool FrameLoaderClientImpl::allowMedia(const KURL& mediaURL)
 211 {
 212     if (m_webFrame->permissionClient())
 213         return m_webFrame->permissionClient()->allowMedia(mediaURL);
 214
 215     return true;
 216 }
 217
 218 bool FrameLoaderClientImpl::allowDisplayingInsecureContent(bool enabledPerSettings, SecurityOrigin* context, const KURL& url)
 219 {
 220     if (m_webFrame->permissionClient())
 221         return m_webFrame->permissionClient()->allowDisplayingInsecureContent(enabledPerSettings, WebSecurityOrigin(context), WebURL(url));
 222
 223     return enabledPerSettings;
 224 }
 225
 226 bool FrameLoaderClientImpl::allowRunningInsecureContent(bool enabledPerSettings, SecurityOrigin* context, const KURL& url)
 227 {
 228     if (m_webFrame->permissionClient())
 229         return m_webFrame->permissionClient()->allowRunningInsecureContent(enabledPerSettings, WebSecurityOrigin(context), WebURL(url));
 230
 231     return enabledPerSettings;
 232 }
 233
 234 void FrameLoaderClientImpl::didNotAllowScript()
 235 {
 236     if (m_webFrame->permissionClient())
 237         m_webFrame->permissionClient()->didNotAllowScript();
 238 }
 239
 240 void FrameLoaderClientImpl::didNotAllowPlugins()
 241 {
 242     if (m_webFrame->permissionClient())
 243         m_webFrame->permissionClient()->didNotAllowPlugins();
 244
 245 }
 246
 247 bool FrameLoaderClientImpl::hasWebView() const
 248 {
 249     return m_webFrame->viewImpl();
 250 }
 251
 252 Frame* FrameLoaderClientImpl::opener() const
 253 {
 254     return toCoreFrame(m_webFrame->opener());
 255 }
 256
 257 void FrameLoaderClientImpl::setOpener(Frame* opener)
 258 {
 259     m_webFrame->setOpener(WebFrame::fromFrame(opener));
 260 }
 261
 262 Frame* FrameLoaderClientImpl::parent() const
 263 {
 264     return toCoreFrame(m_webFrame->parent());
 265 }
 266
 267 Frame* FrameLoaderClientImpl::top() const
 268 {
 269     return toCoreFrame(m_webFrame->top());
 270 }
 271
 272 Frame* FrameLoaderClientImpl::previousSibling() const
 273 {
 274     return toCoreFrame(m_webFrame->previousSibling());
 275 }
 276
 277 Frame* FrameLoaderClientImpl::nextSibling() const
 278 {
 279     return toCoreFrame(m_webFrame->nextSibling());
 280 }
 281
 282 Frame* FrameLoaderClientImpl::firstChild() const
 283 {
 284     return toCoreFrame(m_webFrame->firstChild());
 285 }
 286
 287 Frame* FrameLoaderClientImpl::lastChild() const
 288 {
 289     return toCoreFrame(m_webFrame->lastChild());
 290 }
 291
 292 void FrameLoaderClientImpl::detached()
 293 {
 294     // Alert the client that the frame is being detached. This is the last
 295     // chance we have to communicate with the client.
 296     RefPtrWillBeRawPtr<WebLocalFrameImpl> protector(m_webFrame);
 297
 298     WebFrameClient* client = m_webFrame->client();
 299     if (!client)
 300         return;
 301
 302     m_webFrame->willDetachParent();
 303
 304     // Signal that no further communication with WebFrameClient should take
 305     // place at this point since we are no longer associated with the Page.
 306     m_webFrame->setClient(0);
 307
 308     client->frameDetached(m_webFrame);
 309     // Clear our reference to LocalFrame at the very end, in case the client
 310     // refers to it.
 311     m_webFrame->setCoreFrame(nullptr);
 312 }
 313
 314 void FrameLoaderClientImpl::dispatchWillSendRequest(
 315     DocumentLoader* loader, unsigned long identifier, ResourceRequest& request,
 316     const ResourceResponse& redirectResponse)
 317 {
 318     // Give the WebFrameClient a crack at the request.
 319     if (m_webFrame->client()) {
 320         WrappedResourceRequest webreq(request);
 321         WrappedResourceResponse webresp(redirectResponse);
 322         m_webFrame->client()->willSendRequest(
 323             m_webFrame, identifier, webreq, webresp);
 324     }
 325 }
 326
 327 void FrameLoaderClientImpl::dispatchDidReceiveResponse(DocumentLoader* loader,
 328                                                        unsigned long identifier,
 329                                                        const ResourceResponse& response)
 330 {
 331     if (m_webFrame->client()) {
 332         WrappedResourceResponse webresp(response);
 333         m_webFrame->client()->didReceiveResponse(m_webFrame, identifier, webresp);
 334     }
 335 }
 336
 337 void FrameLoaderClientImpl::dispatchDidChangeResourcePriority(unsigned long identifier, ResourceLoadPriority priority, int intraPriorityValue)
 338 {
 339     if (m_webFrame->client())
 340         m_webFrame->client()->didChangeResourcePriority(m_webFrame, identifier, static_cast<WebURLRequest::Priority>(priority), intraPriorityValue);
 341 }
 342
 343 // Called when a particular resource load completes
 344 void FrameLoaderClientImpl::dispatchDidFinishLoading(DocumentLoader* loader,
 345                                                     unsigned long identifier)
 346 {
 347     if (m_webFrame->client())
 348         m_webFrame->client()->didFinishResourceLoad(m_webFrame, identifier);
 349 }
 350
 351 void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad()
 352 {
 353     if (m_webFrame->client())
 354         m_webFrame->client()->didFinishDocumentLoad(m_webFrame);
 355 }
 356
 357 void FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache(const ResourceRequest& request, const ResourceResponse& response)
 358 {
 359     if (m_webFrame->client())
 360         m_webFrame->client()->didLoadResourceFromMemoryCache(m_webFrame, WrappedResourceRequest(request), WrappedResourceResponse(response));
 361 }
 362
 363 void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents()
 364 {
 365     if (m_webFrame->client())
 366         m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
 367 }
 368
 369 void FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad()
 370 {
 371     if (m_webFrame->client())
 372         m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame);
 373 }
 374
 375 void FrameLoaderClientImpl::dispatchDidNavigateWithinPage(HistoryItem* item, HistoryCommitType commitType)
 376 {
 377     bool shouldCreateHistoryEntry = commitType == StandardCommit;
 378     m_webFrame->viewImpl()->didCommitLoad(shouldCreateHistoryEntry, true);
 379     if (m_webFrame->client())
 380         m_webFrame->client()->didNavigateWithinPage(m_webFrame, WebHistoryItem(item), static_cast<WebHistoryCommitType>(commitType));
 381 }
 382
 383 void FrameLoaderClientImpl::dispatchWillClose()
 384 {
 385     if (m_webFrame->client())
 386         m_webFrame->client()->willClose(m_webFrame);
 387 }
 388
 389 void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad(bool isTransitionNavigation)
 390 {
 391     if (m_webFrame->client())
 392         m_webFrame->client()->didStartProvisionalLoad(m_webFrame, isTransitionNavigation);
 393 }
 394
 395 void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title)
 396 {
 397     if (m_webFrame->client())
 398         m_webFrame->client()->didReceiveTitle(m_webFrame, title, WebTextDirectionLeftToRight);
 399 }
 400
 401 void FrameLoaderClientImpl::dispatchDidChangeIcons(IconType type)
 402 {
 403     if (m_webFrame->client())
 404         m_webFrame->client()->didChangeIcon(m_webFrame, static_cast<WebIconURL::Type>(type));
 405 }
 406
 407 void FrameLoaderClientImpl::dispatchDidCommitLoad(LocalFrame* frame, HistoryItem* item, HistoryCommitType commitType)
 408 {
 409     m_webFrame->viewImpl()->didCommitLoad(commitType == StandardCommit, false);
 410     if (m_webFrame->client())
 411         m_webFrame->client()->didCommitProvisionalLoad(m_webFrame, WebHistoryItem(item), static_cast<WebHistoryCommitType>(commitType));
 412 }
 413
 414 void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
 415     const ResourceError& error)
 416 {
 417     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().provisionalDocumentLoader());
 418     m_webFrame->didFail(error, true);
 419     if (observer)
 420         observer->didFailLoading(error);
 421 }
 422
 423 void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error)
 424 {
 425     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().documentLoader());
 426     m_webFrame->didFail(error, false);
 427     if (observer)
 428         observer->didFailLoading(error);
 429
 430     // Don't clear the redirect chain, this will happen in the middle of client
 431     // redirects, and we need the context. The chain will be cleared when the
 432     // provisional load succeeds or fails, not the "real" one.
 433 }
 434
 435 void FrameLoaderClientImpl::dispatchDidFinishLoad()
 436 {
 437     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().documentLoader());
 438
 439     if (m_webFrame->client())
 440         m_webFrame->client()->didFinishLoad(m_webFrame);
 441
 442     if (observer)
 443         observer->didFinishLoading();
 444
 445     // Don't clear the redirect chain, this will happen in the middle of client
 446     // redirects, and we need the context. The chain will be cleared when the
 447     // provisional load succeeds or fails, not the "real" one.
 448 }
 449
 450 void FrameLoaderClientImpl::dispatchDidFirstVisuallyNonEmptyLayout()
 451 {
 452     if (m_webFrame->client())
 453         m_webFrame->client()->didFirstVisuallyNonEmptyLayout(m_webFrame);
 454 }
 455
 456 void FrameLoaderClientImpl::dispatchDidChangeThemeColor()
 457 {
 458     if (m_webFrame->client())
 459         m_webFrame->client()->didChangeThemeColor();
 460 }
 461
 462 NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(const ResourceRequest& request, DocumentLoader* loader, NavigationPolicy policy, bool isTransitionNavigation)
 463 {
 464     if (!m_webFrame->client())
 465         return NavigationPolicyIgnore;
 466     WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(loader);
 467
 468     WrappedResourceRequest wrappedResourceRequest(request);
 469     WebFrameClient::NavigationPolicyInfo navigationInfo(wrappedResourceRequest);
 470     navigationInfo.frame = m_webFrame;
 471     navigationInfo.extraData = ds->extraData();
 472     navigationInfo.navigationType = ds->navigationType();
 473     navigationInfo.defaultPolicy = static_cast<WebNavigationPolicy>(policy);
 474     navigationInfo.isRedirect = ds->isRedirect();
 475     navigationInfo.isTransitionNavigation = isTransitionNavigation;
 476
 477     WebNavigationPolicy webPolicy = m_webFrame->client()->decidePolicyForNavigation(navigationInfo);
 478     return static_cast<NavigationPolicy>(webPolicy);
 479 }
 480
 481 void FrameLoaderClientImpl::dispatchAddNavigationTransitionData(const String& allowedDestinationOrigin, const String& selector, const String& markup)
 482 {
 483     if (m_webFrame->client())
 484         m_webFrame->client()->addNavigationTransitionData(allowedDestinationOrigin, selector, markup);
 485 }
 486
 487 void FrameLoaderClientImpl::dispatchWillRequestResource(FetchRequest* request)
 488 {
 489     if (m_webFrame->client()) {
 490         WebCachedURLRequest urlRequest(request);
 491         m_webFrame->client()->willRequestResource(m_webFrame, urlRequest);
 492     }
 493 }
 494
 495 void FrameLoaderClientImpl::dispatchWillSendSubmitEvent(HTMLFormElement* form)
 496 {
 497     if (m_webFrame->client())
 498         m_webFrame->client()->willSendSubmitEvent(m_webFrame, WebFormElement(form));
 499 }
 500
 501 void FrameLoaderClientImpl::dispatchWillSubmitForm(HTMLFormElement* form)
 502 {
 503     if (m_webFrame->client())
 504         m_webFrame->client()->willSubmitForm(m_webFrame, WebFormElement(form));
 505 }
 506
 507 void FrameLoaderClientImpl::didStartLoading(LoadStartType loadStartType)
 508 {
 509     if (m_webFrame->client())
 510         m_webFrame->client()->didStartLoading(loadStartType == NavigationToDifferentDocument);
 511 }
 512
 513 void FrameLoaderClientImpl::progressEstimateChanged(double progressEstimate)
 514 {
 515     if (m_webFrame->client())
 516         m_webFrame->client()->didChangeLoadProgress(progressEstimate);
 517 }
 518
 519 void FrameLoaderClientImpl::didStopLoading()
 520 {
 521     if (m_webFrame->client())
 522         m_webFrame->client()->didStopLoading();
 523 }
 524
 525 void FrameLoaderClientImpl::loadURLExternally(const ResourceRequest& request, NavigationPolicy policy, const String& suggestedName)
 526 {
 527     if (m_webFrame->client()) {
 528         ASSERT(m_webFrame->frame()->document());
 529         Fullscreen::fullyExitFullscreen(*m_webFrame->frame()->document());
 530         WrappedResourceRequest webreq(request);
 531         m_webFrame->client()->loadURLExternally(
 532             m_webFrame, webreq, static_cast<WebNavigationPolicy>(policy), suggestedName);
 533     }
 534 }
 535
 536 bool FrameLoaderClientImpl::navigateBackForward(int offset) const
 537 {
 538     WebViewImpl* webview = m_webFrame->viewImpl();
 539     if (!webview->client())
 540         return false;
 541
 542     ASSERT(offset);
 543     if (offset > webview->client()->historyForwardListCount())
 544         return false;
 545     if (offset < -webview->client()->historyBackListCount())
 546         return false;
 547     webview->client()->navigateBackForwardSoon(offset);
 548     return true;
 549 }
 550
 551 void FrameLoaderClientImpl::didAccessInitialDocument()
 552 {
 553     if (m_webFrame->client())
 554         m_webFrame->client()->didAccessInitialDocument(m_webFrame);
 555 }
 556
 557 void FrameLoaderClientImpl::didDisplayInsecureContent()
 558 {
 559     if (m_webFrame->client())
 560         m_webFrame->client()->didDisplayInsecureContent(m_webFrame);
 561 }
 562
 563 void FrameLoaderClientImpl::didRunInsecureContent(SecurityOrigin* origin, const KURL& insecureURL)
 564 {
 565     if (m_webFrame->client())
 566         m_webFrame->client()->didRunInsecureContent(m_webFrame, WebSecurityOrigin(origin), insecureURL);
 567 }
 568
 569 void FrameLoaderClientImpl::didDetectXSS(const KURL& insecureURL, bool didBlockEntirePage)
 570 {
 571     if (m_webFrame->client())
 572         m_webFrame->client()->didDetectXSS(m_webFrame, insecureURL, didBlockEntirePage);
 573 }
 574
 575 void FrameLoaderClientImpl::didDispatchPingLoader(const KURL& url)
 576 {
 577     if (m_webFrame->client())
 578         m_webFrame->client()->didDispatchPingLoader(m_webFrame, url);
 579 }
 580
 581 void FrameLoaderClientImpl::selectorMatchChanged(const Vector<String>& addedSelectors, const Vector<String>& removedSelectors)
 582 {
 583     if (WebFrameClient* client = m_webFrame->client())
 584         client->didMatchCSS(m_webFrame, WebVector<WebString>(addedSelectors), WebVector<WebString>(removedSelectors));
 585 }
 586
 587 PassRefPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
 588 {
 589     RefPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(frame, request, data);
 590     if (m_webFrame->client())
 591         m_webFrame->client()->didCreateDataSource(m_webFrame, ds.get());
 592     return ds.release();
 593 }
 594
 595 String FrameLoaderClientImpl::userAgent(const KURL& url)
 596 {
 597     WebString override = m_webFrame->client()->userAgentOverride(m_webFrame, WebURL(url));
 598     if (!override.isEmpty())
 599         return override;
 600
 601     return Platform::current()->userAgent();
 602 }
 603
 604 String FrameLoaderClientImpl::doNotTrackValue()
 605 {
 606     WebString doNotTrack = m_webFrame->client()->doNotTrackValue(m_webFrame);
 607     if (!doNotTrack.isEmpty())
 608         return doNotTrack;
 609     return String();
 610 }
 611
 612 // Called when the FrameLoader goes into a state in which a new page load
 613 // will occur.
 614 void FrameLoaderClientImpl::transitionToCommittedForNewPage()
 615 {
 616     m_webFrame->createFrameView();
 617 }
 618
 619 PassRefPtrWillBeRawPtr<LocalFrame> FrameLoaderClientImpl::createFrame(
 620     const KURL& url,
 621     const AtomicString& name,
 622     HTMLFrameOwnerElement* ownerElement)
 623 {
 624     FrameLoadRequest frameRequest(m_webFrame->frame()->document(), url, name);
 625     return m_webFrame->createChildFrame(frameRequest, ownerElement);
 626 }
 627
 628 bool FrameLoaderClientImpl::canCreatePluginWithoutRenderer(const String& mimeType) const
 629 {
 630     if (!m_webFrame->client())
 631         return false;
 632
 633     return m_webFrame->client()->canCreatePluginWithoutRenderer(mimeType);
 634 }
 635
 636 PassOwnPtrWillBeRawPtr<PluginPlaceholder> FrameLoaderClientImpl::createPluginPlaceholder(
 637     Document& document,
 638     const KURL& url,
 639     const Vector<String>& paramNames,
 640     const Vector<String>& paramValues,
 641     const String& mimeType,
 642     bool loadManually)
 643 {
 644     if (!m_webFrame->client())
 645         return nullptr;
 646
 647     WebPluginParams params;
 648     params.url = url;
 649     params.mimeType = mimeType;
 650     params.attributeNames = paramNames;
 651     params.attributeValues = paramValues;
 652     params.loadManually = loadManually;
 653
 654     OwnPtr<WebPluginPlaceholder> webPluginPlaceholder = adoptPtr(
 655         m_webFrame->client()->createPluginPlaceholder(m_webFrame, params));
 656     if (!webPluginPlaceholder)
 657         return nullptr;
 658
 659     return PluginPlaceholderImpl::create(webPluginPlaceholder.release(), document);
 660 }
 661
 662 PassRefPtrWillBeRawPtr<Widget> FrameLoaderClientImpl::createPlugin(
 663     HTMLPlugInElement* element,
 664     const KURL& url,
 665     const Vector<String>& paramNames,
 666     const Vector<String>& paramValues,
 667     const String& mimeType,
 668     bool loadManually,
 669     DetachedPluginPolicy policy)
 670 {
 671     if (!m_webFrame->client())
 672         return nullptr;
 673
 674     WebPluginParams params;
 675     params.url = url;
 676     params.mimeType = mimeType;
 677     params.attributeNames = paramNames;
 678     params.attributeValues = paramValues;
 679     params.loadManually = loadManually;
 680
 681     WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params);
 682     if (!webPlugin)
 683         return nullptr;
 684
 685     // The container takes ownership of the WebPlugin.
 686     RefPtrWillBeRawPtr<WebPluginContainerImpl> container =
 687         WebPluginContainerImpl::create(element, webPlugin);
 688
 689     if (!webPlugin->initialize(container.get())) {
 690 #if ENABLE(OILPAN)
 691         container->dispose();
 692 #endif
 693         return nullptr;
 694     }
 695
 696     if (policy != AllowDetachedPlugin && !element->renderer()) {
 697 #if ENABLE(OILPAN)
 698         container->dispose();
 699 #endif
 700         return nullptr;
 701     }
 702
 703     return container;
 704 }
 705
 706 PassRefPtrWillBeRawPtr<Widget> FrameLoaderClientImpl::createJavaAppletWidget(
 707     HTMLAppletElement* element,
 708     const KURL& /* baseURL */,
 709     const Vector<String>& paramNames,
 710     const Vector<String>& paramValues)
 711 {
 712     return createPlugin(element, KURL(), paramNames, paramValues,
 713         "application/x-java-applet", false, FailOnDetachedPlugin);
 714 }
 715
 716 ObjectContentType FrameLoaderClientImpl::objectContentType(
 717     const KURL& url,
 718     const String& explicitMimeType,
 719     bool shouldPreferPlugInsForImages)
 720 {
 721     // This code is based on Apple's implementation from
 722     // WebCoreSupport/WebFrameBridge.mm.
 723
 724     String mimeType = explicitMimeType;
 725     if (mimeType.isEmpty()) {
 726         // Try to guess the MIME type based off the extension.
 727         String filename = url.lastPathComponent();
 728         int extensionPos = filename.reverseFind('.');
 729         if (extensionPos >= 0) {
 730             String extension = filename.substring(extensionPos + 1);
 731             mimeType = MIMETypeRegistry::getMIMETypeForExtension(extension);
 732             if (mimeType.isEmpty()) {
 733                 // If there's no mimetype registered for the extension, check to see
 734                 // if a plugin can handle the extension.
 735                 mimeType = getPluginMimeTypeFromExtension(extension);
 736             }
 737         }
 738
 739         if (mimeType.isEmpty())
 740             return ObjectContentFrame;
 741     }
 742
 743     // If Chrome is started with the --disable-plugins switch, pluginData is 0.
 744     PluginData* pluginData = m_webFrame->frame()->page()->pluginData();
 745     bool plugInSupportsMIMEType = pluginData && pluginData->supportsMimeType(mimeType);
 746
 747     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
 748         return shouldPreferPlugInsForImages && plugInSupportsMIMEType ? ObjectContentNetscapePlugin : ObjectContentImage;
 749
 750     if (plugInSupportsMIMEType)
 751         return ObjectContentNetscapePlugin;
 752
 753     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
 754         return ObjectContentFrame;
 755
 756     return ObjectContentNone;
 757 }
 758
 759 PassOwnPtr<WebPluginLoadObserver> FrameLoaderClientImpl::pluginLoadObserver(DocumentLoader* loader)
 760 {
 761     return WebDataSourceImpl::fromDocumentLoader(loader)->releasePluginLoadObserver();
 762 }
 763
 764 WebCookieJar* FrameLoaderClientImpl::cookieJar() const
 765 {
 766     if (!m_webFrame->client())
 767         return 0;
 768     return m_webFrame->client()->cookieJar(m_webFrame);
 769 }
 770
 771 bool FrameLoaderClientImpl::willCheckAndDispatchMessageEvent(
 772     SecurityOrigin* target, MessageEvent* event, LocalFrame* sourceFrame) const
 773 {
 774     if (!m_webFrame->client())
 775         return false;
 776     return m_webFrame->client()->willCheckAndDispatchMessageEvent(
 777         WebLocalFrameImpl::fromFrame(sourceFrame), m_webFrame, WebSecurityOrigin(target), WebDOMMessageEvent(event));
 778 }
 779
 780 void FrameLoaderClientImpl::didChangeName(const String& name)
 781 {
 782     if (!m_webFrame->client())
 783         return;
 784     m_webFrame->client()->didChangeName(m_webFrame, name);
 785 }
 786
 787 void FrameLoaderClientImpl::dispatchWillOpenWebSocket(WebSocketHandle* handle)
 788 {
 789     m_webFrame->client()->willOpenWebSocket(handle);
 790 }
 791
 792 void FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler(WebRTCPeerConnectionHandler* handler)
 793 {
 794     m_webFrame->client()->willStartUsingPeerConnectionHandler(webFrame(), handler);
 795 }
 796
 797 void FrameLoaderClientImpl::didRequestAutocomplete(HTMLFormElement* form)
 798 {
 799     if (m_webFrame->viewImpl() && m_webFrame->viewImpl()->autofillClient())
 800         m_webFrame->viewImpl()->autofillClient()->didRequestAutocomplete(WebFormElement(form));
 801 }
 802
 803 bool FrameLoaderClientImpl::allowWebGL(bool enabledPerSettings)
 804 {
 805     if (m_webFrame->client())
 806         return m_webFrame->client()->allowWebGL(m_webFrame, enabledPerSettings);
 807
 808     return enabledPerSettings;
 809 }
 810
 811 void FrameLoaderClientImpl::didLoseWebGLContext(int arbRobustnessContextLostReason)
 812 {
 813     if (m_webFrame->client())
 814         m_webFrame->client()->didLoseWebGLContext(m_webFrame, arbRobustnessContextLostReason);
 815 }
 816
 817 void FrameLoaderClientImpl::dispatchWillInsertBody()
 818 {
 819     if (m_webFrame->client())
 820         m_webFrame->client()->willInsertBody(m_webFrame);
 821
 822     if (m_webFrame->viewImpl())
 823         m_webFrame->viewImpl()->willInsertBody(m_webFrame);
 824 }
 825
 826 PassOwnPtr<WebServiceWorkerProvider> FrameLoaderClientImpl::createServiceWorkerProvider()
 827 {
 828     if (!m_webFrame->client())
 829         return nullptr;
 830     return adoptPtr(m_webFrame->client()->createServiceWorkerProvider(m_webFrame));
 831 }
 832
 833 bool FrameLoaderClientImpl::isControlledByServiceWorker(DocumentLoader& loader)
 834 {
 835     return m_webFrame->client() && m_webFrame->client()->isControlledByServiceWorker(*WebDataSourceImpl::fromDocumentLoader(&loader));
 836 }
 837
 838 int64_t FrameLoaderClientImpl::serviceWorkerID(DocumentLoader& loader)
 839 {
 840     if (!m_webFrame->client())
 841         return -1;
 842     return m_webFrame->client()->serviceWorkerID(*WebDataSourceImpl::fromDocumentLoader(&loader));
 843 }
 844
 845 SharedWorkerRepositoryClient* FrameLoaderClientImpl::sharedWorkerRepositoryClient()
 846 {
 847     return m_webFrame->sharedWorkerRepositoryClient();
 848 }
 849
 850 PassOwnPtr<WebApplicationCacheHost> FrameLoaderClientImpl::createApplicationCacheHost(WebApplicationCacheHostClient* client)
 851 {
 852     if (!m_webFrame->client())
 853         return nullptr;
 854     return adoptPtr(m_webFrame->client()->createApplicationCacheHost(m_webFrame, client));
 855 }
 856
 857 void FrameLoaderClientImpl::didStopAllLoaders()
 858 {
 859     if (m_webFrame->client())
 860         m_webFrame->client()->didAbortLoading(m_webFrame);
 861 }
 862
 863 void FrameLoaderClientImpl::dispatchDidChangeManifest()
 864 {
 865     if (m_webFrame->client())
 866         m_webFrame->client()->didChangeManifest(m_webFrame);
 867 }
 868
 869 unsigned FrameLoaderClientImpl::backForwardLength()
 870 {
 871     WebViewImpl* webview = m_webFrame->viewImpl();
 872     if (!webview || !webview->client())
 873         return 0;
 874     return webview->client()->historyBackListCount() + 1 + webview->client()->historyForwardListCount();
 875 }
 876
 877 } // namespace blink