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/FullscreenElementStack.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/network/SocketStreamHandleInternal.h"
  65 #include "platform/plugins/PluginData.h"
  66 #include "public/platform/Platform.h"
  67 #include "public/platform/WebApplicationCacheHost.h"
  68 #include "public/platform/WebMimeRegistry.h"
  69 #include "public/platform/WebRTCPeerConnectionHandler.h"
  70 #include "public/platform/WebServiceWorkerProvider.h"
  71 #include "public/platform/WebServiceWorkerProviderClient.h"
  72 #include "public/platform/WebSocketStreamHandle.h"
  73 #include "public/platform/WebURL.h"
  74 #include "public/platform/WebURLError.h"
  75 #include "public/platform/WebVector.h"
  76 #include "public/web/WebAutofillClient.h"
  77 #include "public/web/WebCachedURLRequest.h"
  78 #include "public/web/WebDOMEvent.h"
  79 #include "public/web/WebDocument.h"
  80 #include "public/web/WebFormElement.h"
  81 #include "public/web/WebFrameClient.h"
  82 #include "public/web/WebNode.h"
  83 #include "public/web/WebPermissionClient.h"
  84 #include "public/web/WebPlugin.h"
  85 #include "public/web/WebPluginParams.h"
  86 #include "public/web/WebSecurityOrigin.h"
  87 #include "public/web/WebViewClient.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             if (RuntimeEnabledFeatures::gamepadEnabled())
 122                 NavigatorGamepad::from(*document);
 123             if (RuntimeEnabledFeatures::serviceWorkerEnabled())
 124                 NavigatorServiceWorker::from(*document);
 125         }
 126     }
 127 }
 128
 129 void FrameLoaderClientImpl::documentElementAvailable()
 130 {
 131     if (m_webFrame->client())
 132         m_webFrame->client()->didCreateDocumentElement(m_webFrame);
 133 }
 134
 135 void FrameLoaderClientImpl::didCreateScriptContext(v8::Handle<v8::Context> context, int extensionGroup, int worldId)
 136 {
 137     WebViewImpl* webview = m_webFrame->viewImpl();
 138     if (webview->devToolsAgentPrivate())
 139         webview->devToolsAgentPrivate()->didCreateScriptContext(m_webFrame, worldId);
 140     if (m_webFrame->client())
 141         m_webFrame->client()->didCreateScriptContext(m_webFrame, context, extensionGroup, worldId);
 142 }
 143
 144 void FrameLoaderClientImpl::willReleaseScriptContext(v8::Handle<v8::Context> context, int worldId)
 145 {
 146     if (m_webFrame->client())
 147         m_webFrame->client()->willReleaseScriptContext(m_webFrame, context, worldId);
 148 }
 149
 150 bool FrameLoaderClientImpl::allowScriptExtension(const String& extensionName,
 151                                                  int extensionGroup,
 152                                                  int worldId)
 153 {
 154     if (m_webFrame->permissionClient())
 155         return m_webFrame->permissionClient()->allowScriptExtension(extensionName, extensionGroup, worldId);
 156
 157     return true;
 158 }
 159
 160 void FrameLoaderClientImpl::didChangeScrollOffset()
 161 {
 162     if (m_webFrame->client())
 163         m_webFrame->client()->didChangeScrollOffset(m_webFrame);
 164 }
 165
 166 void FrameLoaderClientImpl::didUpdateCurrentHistoryItem()
 167 {
 168     if (m_webFrame->client())
 169         m_webFrame->client()->didUpdateCurrentHistoryItem(m_webFrame);
 170 }
 171
 172 void FrameLoaderClientImpl::didRemoveAllPendingStylesheet()
 173 {
 174     WebViewImpl* webview = m_webFrame->viewImpl();
 175     if (webview)
 176         webview->didRemoveAllPendingStylesheet(m_webFrame);
 177 }
 178
 179 bool FrameLoaderClientImpl::allowScript(bool enabledPerSettings)
 180 {
 181     if (m_webFrame->permissionClient())
 182         return m_webFrame->permissionClient()->allowScript(enabledPerSettings);
 183
 184     return enabledPerSettings;
 185 }
 186
 187 bool FrameLoaderClientImpl::allowScriptFromSource(bool enabledPerSettings, const KURL& scriptURL)
 188 {
 189     if (m_webFrame->permissionClient())
 190         return m_webFrame->permissionClient()->allowScriptFromSource(enabledPerSettings, scriptURL);
 191
 192     return enabledPerSettings;
 193 }
 194
 195 bool FrameLoaderClientImpl::allowPlugins(bool enabledPerSettings)
 196 {
 197     if (m_webFrame->permissionClient())
 198         return m_webFrame->permissionClient()->allowPlugins(enabledPerSettings);
 199
 200     return enabledPerSettings;
 201 }
 202
 203 bool FrameLoaderClientImpl::allowImage(bool enabledPerSettings, const KURL& imageURL)
 204 {
 205     if (m_webFrame->permissionClient())
 206         return m_webFrame->permissionClient()->allowImage(enabledPerSettings, imageURL);
 207
 208     return enabledPerSettings;
 209 }
 210
 211 bool FrameLoaderClientImpl::allowMedia(const KURL& mediaURL)
 212 {
 213     if (m_webFrame->permissionClient())
 214         return m_webFrame->permissionClient()->allowMedia(mediaURL);
 215
 216     return true;
 217 }
 218
 219 bool FrameLoaderClientImpl::allowDisplayingInsecureContent(bool enabledPerSettings, SecurityOrigin* context, const KURL& url)
 220 {
 221     if (m_webFrame->permissionClient())
 222         return m_webFrame->permissionClient()->allowDisplayingInsecureContent(enabledPerSettings, WebSecurityOrigin(context), WebURL(url));
 223
 224     return enabledPerSettings;
 225 }
 226
 227 bool FrameLoaderClientImpl::allowRunningInsecureContent(bool enabledPerSettings, SecurityOrigin* context, const KURL& url)
 228 {
 229     if (m_webFrame->permissionClient())
 230         return m_webFrame->permissionClient()->allowRunningInsecureContent(enabledPerSettings, WebSecurityOrigin(context), WebURL(url));
 231
 232     return enabledPerSettings;
 233 }
 234
 235 void FrameLoaderClientImpl::didNotAllowScript()
 236 {
 237     if (m_webFrame->permissionClient())
 238         m_webFrame->permissionClient()->didNotAllowScript();
 239 }
 240
 241 void FrameLoaderClientImpl::didNotAllowPlugins()
 242 {
 243     if (m_webFrame->permissionClient())
 244         m_webFrame->permissionClient()->didNotAllowPlugins();
 245
 246 }
 247
 248 bool FrameLoaderClientImpl::hasWebView() const
 249 {
 250     return m_webFrame->viewImpl();
 251 }
 252
 253 Frame* FrameLoaderClientImpl::opener() const
 254 {
 255     return toCoreFrame(m_webFrame->opener());
 256 }
 257
 258 void FrameLoaderClientImpl::setOpener(Frame* opener)
 259 {
 260     // FIXME: Temporary hack to stage converting locations that really should be Frame.
 261     m_webFrame->setOpener(WebLocalFrameImpl::fromFrame(toLocalFrame(opener)));
 262 }
 263
 264 Frame* FrameLoaderClientImpl::parent() const
 265 {
 266     return toCoreFrame(m_webFrame->parent());
 267 }
 268
 269 Frame* FrameLoaderClientImpl::top() const
 270 {
 271     return toCoreFrame(m_webFrame->top());
 272 }
 273
 274 Frame* FrameLoaderClientImpl::previousSibling() const
 275 {
 276     return toCoreFrame(m_webFrame->previousSibling());
 277 }
 278
 279 Frame* FrameLoaderClientImpl::nextSibling() const
 280 {
 281     return toCoreFrame(m_webFrame->nextSibling());
 282 }
 283
 284 Frame* FrameLoaderClientImpl::firstChild() const
 285 {
 286     return toCoreFrame(m_webFrame->firstChild());
 287 }
 288
 289 Frame* FrameLoaderClientImpl::lastChild() const
 290 {
 291     return toCoreFrame(m_webFrame->lastChild());
 292 }
 293
 294 void FrameLoaderClientImpl::detachedFromParent()
 295 {
 296     // Alert the client that the frame is being detached. This is the last
 297     // chance we have to communicate with the client.
 298     RefPtr<WebLocalFrameImpl> protector(m_webFrame);
 299
 300     WebFrameClient* client = m_webFrame->client();
 301     if (!client)
 302         return;
 303
 304     m_webFrame->willDetachParent();
 305
 306     // Signal that no further communication with WebFrameClient should take
 307     // place at this point since we are no longer associated with the Page.
 308     m_webFrame->setClient(0);
 309
 310     client->frameDetached(m_webFrame);
 311     // Clear our reference to LocalFrame at the very end, in case the client
 312     // refers to it.
 313     m_webFrame->setCoreFrame(nullptr);
 314 }
 315
 316 void FrameLoaderClientImpl::dispatchWillSendRequest(
 317     DocumentLoader* loader, unsigned long identifier, ResourceRequest& request,
 318     const ResourceResponse& redirectResponse)
 319 {
 320     // Give the WebFrameClient a crack at the request.
 321     if (m_webFrame->client()) {
 322         WrappedResourceRequest webreq(request);
 323         WrappedResourceResponse webresp(redirectResponse);
 324         m_webFrame->client()->willSendRequest(
 325             m_webFrame, identifier, webreq, webresp);
 326     }
 327 }
 328
 329 void FrameLoaderClientImpl::dispatchDidReceiveResponse(DocumentLoader* loader,
 330                                                        unsigned long identifier,
 331                                                        const ResourceResponse& response)
 332 {
 333     if (m_webFrame->client()) {
 334         WrappedResourceResponse webresp(response);
 335         m_webFrame->client()->didReceiveResponse(m_webFrame, identifier, webresp);
 336     }
 337 }
 338
 339 void FrameLoaderClientImpl::dispatchDidChangeResourcePriority(unsigned long identifier, ResourceLoadPriority priority, int intraPriorityValue)
 340 {
 341     if (m_webFrame->client())
 342         m_webFrame->client()->didChangeResourcePriority(m_webFrame, identifier, static_cast<WebURLRequest::Priority>(priority), intraPriorityValue);
 343 }
 344
 345 // Called when a particular resource load completes
 346 void FrameLoaderClientImpl::dispatchDidFinishLoading(DocumentLoader* loader,
 347                                                     unsigned long identifier)
 348 {
 349     if (m_webFrame->client())
 350         m_webFrame->client()->didFinishResourceLoad(m_webFrame, identifier);
 351 }
 352
 353 void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad()
 354 {
 355     if (m_webFrame->client())
 356         m_webFrame->client()->didFinishDocumentLoad(m_webFrame);
 357 }
 358
 359 void FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache(const ResourceRequest& request, const ResourceResponse& response)
 360 {
 361     if (m_webFrame->client())
 362         m_webFrame->client()->didLoadResourceFromMemoryCache(m_webFrame, WrappedResourceRequest(request), WrappedResourceResponse(response));
 363 }
 364
 365 void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents()
 366 {
 367     if (m_webFrame->client())
 368         m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
 369 }
 370
 371 void FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad()
 372 {
 373     if (m_webFrame->client())
 374         m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame);
 375 }
 376
 377 void FrameLoaderClientImpl::dispatchDidNavigateWithinPage(HistoryItem* item, HistoryCommitType commitType)
 378 {
 379     bool shouldCreateHistoryEntry = commitType == StandardCommit;
 380     m_webFrame->viewImpl()->didCommitLoad(shouldCreateHistoryEntry, true);
 381     if (m_webFrame->client())
 382         m_webFrame->client()->didNavigateWithinPage(m_webFrame, WebHistoryItem(item), static_cast<WebHistoryCommitType>(commitType));
 383 }
 384
 385 void FrameLoaderClientImpl::dispatchWillClose()
 386 {
 387     if (m_webFrame->client())
 388         m_webFrame->client()->willClose(m_webFrame);
 389 }
 390
 391 void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad(bool isTransitionNavigation)
 392 {
 393     if (m_webFrame->client())
 394         m_webFrame->client()->didStartProvisionalLoad(m_webFrame, isTransitionNavigation);
 395 }
 396
 397 void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title)
 398 {
 399     if (m_webFrame->client())
 400         m_webFrame->client()->didReceiveTitle(m_webFrame, title, WebTextDirectionLeftToRight);
 401 }
 402
 403 void FrameLoaderClientImpl::dispatchDidChangeIcons(IconType type)
 404 {
 405     if (m_webFrame->client())
 406         m_webFrame->client()->didChangeIcon(m_webFrame, static_cast<WebIconURL::Type>(type));
 407 }
 408
 409 void FrameLoaderClientImpl::dispatchDidCommitLoad(LocalFrame* frame, HistoryItem* item, HistoryCommitType commitType)
 410 {
 411     m_webFrame->viewImpl()->didCommitLoad(commitType == StandardCommit, false);
 412     if (m_webFrame->client())
 413         m_webFrame->client()->didCommitProvisionalLoad(m_webFrame, WebHistoryItem(item), static_cast<WebHistoryCommitType>(commitType));
 414 }
 415
 416 void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
 417     const ResourceError& error)
 418 {
 419     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().provisionalDocumentLoader());
 420     m_webFrame->didFail(error, true);
 421     if (observer)
 422         observer->didFailLoading(error);
 423 }
 424
 425 void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error)
 426 {
 427     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().documentLoader());
 428     m_webFrame->didFail(error, false);
 429     if (observer)
 430         observer->didFailLoading(error);
 431
 432     // Don't clear the redirect chain, this will happen in the middle of client
 433     // redirects, and we need the context. The chain will be cleared when the
 434     // provisional load succeeds or fails, not the "real" one.
 435 }
 436
 437 void FrameLoaderClientImpl::dispatchDidFinishLoad()
 438 {
 439     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().documentLoader());
 440
 441     if (m_webFrame->client())
 442         m_webFrame->client()->didFinishLoad(m_webFrame);
 443
 444     if (observer)
 445         observer->didFinishLoading();
 446
 447     // Don't clear the redirect chain, this will happen in the middle of client
 448     // redirects, and we need the context. The chain will be cleared when the
 449     // provisional load succeeds or fails, not the "real" one.
 450 }
 451
 452 void FrameLoaderClientImpl::dispatchDidFirstVisuallyNonEmptyLayout()
 453 {
 454     if (m_webFrame->client())
 455         m_webFrame->client()->didFirstVisuallyNonEmptyLayout(m_webFrame);
 456 }
 457
 458 void FrameLoaderClientImpl::dispatchDidChangeThemeColor()
 459 {
 460     if (m_webFrame->client())
 461         m_webFrame->client()->didChangeThemeColor();
 462 }
 463
 464 NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(const ResourceRequest& request, DocumentLoader* loader, NavigationPolicy policy, bool isTransitionNavigation)
 465 {
 466     if (!m_webFrame->client())
 467         return NavigationPolicyIgnore;
 468     WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(loader);
 469
 470     WrappedResourceRequest wrappedResourceRequest(request);
 471     WebFrameClient::NavigationPolicyInfo navigationInfo(wrappedResourceRequest);
 472     navigationInfo.frame = m_webFrame;
 473     navigationInfo.extraData = ds->extraData();
 474     navigationInfo.navigationType = ds->navigationType();
 475     navigationInfo.defaultPolicy = static_cast<WebNavigationPolicy>(policy);
 476     navigationInfo.isRedirect = ds->isRedirect();
 477     navigationInfo.isTransitionNavigation = isTransitionNavigation;
 478
 479     WebNavigationPolicy webPolicy = m_webFrame->client()->decidePolicyForNavigation(navigationInfo);
 480     return static_cast<NavigationPolicy>(webPolicy);
 481 }
 482
 483 void FrameLoaderClientImpl::dispatchAddNavigationTransitionData(const String& allowedDestinationOrigin, const String& selector, const String& markup)
 484 {
 485     if (m_webFrame->client())
 486         m_webFrame->client()->addNavigationTransitionData(allowedDestinationOrigin, selector, markup);
 487 }
 488
 489 void FrameLoaderClientImpl::dispatchWillRequestResource(FetchRequest* request)
 490 {
 491     if (m_webFrame->client()) {
 492         WebCachedURLRequest urlRequest(request);
 493         m_webFrame->client()->willRequestResource(m_webFrame, urlRequest);
 494     }
 495 }
 496
 497 void FrameLoaderClientImpl::dispatchWillSendSubmitEvent(HTMLFormElement* form)
 498 {
 499     if (m_webFrame->client())
 500         m_webFrame->client()->willSendSubmitEvent(m_webFrame, WebFormElement(form));
 501 }
 502
 503 void FrameLoaderClientImpl::dispatchWillSubmitForm(HTMLFormElement* form)
 504 {
 505     if (m_webFrame->client())
 506         m_webFrame->client()->willSubmitForm(m_webFrame, WebFormElement(form));
 507 }
 508
 509 void FrameLoaderClientImpl::didStartLoading(LoadStartType loadStartType)
 510 {
 511     if (m_webFrame->client())
 512         m_webFrame->client()->didStartLoading(loadStartType == NavigationToDifferentDocument);
 513 }
 514
 515 void FrameLoaderClientImpl::progressEstimateChanged(double progressEstimate)
 516 {
 517     if (m_webFrame->client())
 518         m_webFrame->client()->didChangeLoadProgress(progressEstimate);
 519 }
 520
 521 void FrameLoaderClientImpl::didStopLoading()
 522 {
 523     if (m_webFrame->client())
 524         m_webFrame->client()->didStopLoading();
 525 }
 526
 527 void FrameLoaderClientImpl::loadURLExternally(const ResourceRequest& request, NavigationPolicy policy, const String& suggestedName)
 528 {
 529     if (m_webFrame->client()) {
 530         ASSERT(m_webFrame->frame()->document());
 531         FullscreenElementStack::from(*m_webFrame->frame()->document()).fullyExitFullscreen();
 532         WrappedResourceRequest webreq(request);
 533         m_webFrame->client()->loadURLExternally(
 534             m_webFrame, webreq, static_cast<WebNavigationPolicy>(policy), suggestedName);
 535     }
 536 }
 537
 538 bool FrameLoaderClientImpl::navigateBackForward(int offset) const
 539 {
 540     WebViewImpl* webview = m_webFrame->viewImpl();
 541     if (!webview->client())
 542         return false;
 543
 544     ASSERT(offset);
 545     offset = std::min(offset, webview->client()->historyForwardListCount());
 546     offset = std::max(offset, -webview->client()->historyBackListCount());
 547     if (!offset)
 548         return false;
 549     webview->client()->navigateBackForwardSoon(offset);
 550     return true;
 551 }
 552
 553 void FrameLoaderClientImpl::didAccessInitialDocument()
 554 {
 555     if (m_webFrame->client())
 556         m_webFrame->client()->didAccessInitialDocument(m_webFrame);
 557 }
 558
 559 void FrameLoaderClientImpl::didDisplayInsecureContent()
 560 {
 561     if (m_webFrame->client())
 562         m_webFrame->client()->didDisplayInsecureContent(m_webFrame);
 563 }
 564
 565 void FrameLoaderClientImpl::didRunInsecureContent(SecurityOrigin* origin, const KURL& insecureURL)
 566 {
 567     if (m_webFrame->client())
 568         m_webFrame->client()->didRunInsecureContent(m_webFrame, WebSecurityOrigin(origin), insecureURL);
 569 }
 570
 571 void FrameLoaderClientImpl::didDetectXSS(const KURL& insecureURL, bool didBlockEntirePage)
 572 {
 573     if (m_webFrame->client())
 574         m_webFrame->client()->didDetectXSS(m_webFrame, insecureURL, didBlockEntirePage);
 575 }
 576
 577 void FrameLoaderClientImpl::didDispatchPingLoader(const KURL& url)
 578 {
 579     if (m_webFrame->client())
 580         m_webFrame->client()->didDispatchPingLoader(m_webFrame, url);
 581 }
 582
 583 void FrameLoaderClientImpl::selectorMatchChanged(const Vector<String>& addedSelectors, const Vector<String>& removedSelectors)
 584 {
 585     if (WebFrameClient* client = m_webFrame->client())
 586         client->didMatchCSS(m_webFrame, WebVector<WebString>(addedSelectors), WebVector<WebString>(removedSelectors));
 587 }
 588
 589 PassRefPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
 590 {
 591     RefPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(frame, request, data);
 592     if (m_webFrame->client())
 593         m_webFrame->client()->didCreateDataSource(m_webFrame, ds.get());
 594     return ds.release();
 595 }
 596
 597 String FrameLoaderClientImpl::userAgent(const KURL& url)
 598 {
 599     WebString override = m_webFrame->client()->userAgentOverride(m_webFrame, WebURL(url));
 600     if (!override.isEmpty())
 601         return override;
 602
 603     return Platform::current()->userAgent();
 604 }
 605
 606 String FrameLoaderClientImpl::doNotTrackValue()
 607 {
 608     WebString doNotTrack = m_webFrame->client()->doNotTrackValue(m_webFrame);
 609     if (!doNotTrack.isEmpty())
 610         return doNotTrack;
 611     return String();
 612 }
 613
 614 // Called when the FrameLoader goes into a state in which a new page load
 615 // will occur.
 616 void FrameLoaderClientImpl::transitionToCommittedForNewPage()
 617 {
 618     m_webFrame->createFrameView();
 619 }
 620
 621 PassRefPtr<LocalFrame> FrameLoaderClientImpl::createFrame(
 622     const KURL& url,
 623     const AtomicString& name,
 624     const Referrer& referrer,
 625     HTMLFrameOwnerElement* ownerElement)
 626 {
 627     FrameLoadRequest frameRequest(m_webFrame->frame()->document(),
 628         ResourceRequest(url, referrer), name);
 629     return m_webFrame->createChildFrame(frameRequest, ownerElement);
 630 }
 631
 632 bool FrameLoaderClientImpl::canCreatePluginWithoutRenderer(const String& mimeType) const
 633 {
 634     if (!m_webFrame->client())
 635         return false;
 636
 637     return m_webFrame->client()->canCreatePluginWithoutRenderer(mimeType);
 638 }
 639
 640 PassRefPtr<Widget> FrameLoaderClientImpl::createPlugin(
 641     HTMLPlugInElement* element,
 642     const KURL& url,
 643     const Vector<String>& paramNames,
 644     const Vector<String>& paramValues,
 645     const String& mimeType,
 646     bool loadManually,
 647     DetachedPluginPolicy policy)
 648 {
 649     if (!m_webFrame->client())
 650         return nullptr;
 651
 652     WebPluginParams params;
 653     params.url = url;
 654     params.mimeType = mimeType;
 655     params.attributeNames = paramNames;
 656     params.attributeValues = paramValues;
 657     params.loadManually = loadManually;
 658
 659     WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params);
 660     if (!webPlugin)
 661         return nullptr;
 662
 663     // The container takes ownership of the WebPlugin.
 664     RefPtr<WebPluginContainerImpl> container =
 665         WebPluginContainerImpl::create(element, webPlugin);
 666
 667     if (!webPlugin->initialize(container.get()))
 668         return nullptr;
 669
 670     if (policy != AllowDetachedPlugin && !element->renderer())
 671         return nullptr;
 672
 673     return container;
 674 }
 675
 676 PassRefPtr<Widget> FrameLoaderClientImpl::createJavaAppletWidget(
 677     HTMLAppletElement* element,
 678     const KURL& /* baseURL */,
 679     const Vector<String>& paramNames,
 680     const Vector<String>& paramValues)
 681 {
 682     return createPlugin(element, KURL(), paramNames, paramValues,
 683         "application/x-java-applet", false, FailOnDetachedPlugin);
 684 }
 685
 686 ObjectContentType FrameLoaderClientImpl::objectContentType(
 687     const KURL& url,
 688     const String& explicitMimeType,
 689     bool shouldPreferPlugInsForImages)
 690 {
 691     // This code is based on Apple's implementation from
 692     // WebCoreSupport/WebFrameBridge.mm.
 693
 694     String mimeType = explicitMimeType;
 695     if (mimeType.isEmpty()) {
 696         // Try to guess the MIME type based off the extension.
 697         String filename = url.lastPathComponent();
 698         int extensionPos = filename.reverseFind('.');
 699         if (extensionPos >= 0) {
 700             String extension = filename.substring(extensionPos + 1);
 701             mimeType = MIMETypeRegistry::getMIMETypeForExtension(extension);
 702             if (mimeType.isEmpty()) {
 703                 // If there's no mimetype registered for the extension, check to see
 704                 // if a plugin can handle the extension.
 705                 mimeType = getPluginMimeTypeFromExtension(extension);
 706             }
 707         }
 708
 709         if (mimeType.isEmpty())
 710             return ObjectContentFrame;
 711     }
 712
 713     // If Chrome is started with the --disable-plugins switch, pluginData is 0.
 714     PluginData* pluginData = m_webFrame->frame()->page()->pluginData();
 715     bool plugInSupportsMIMEType = pluginData && pluginData->supportsMimeType(mimeType);
 716
 717     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
 718         return shouldPreferPlugInsForImages && plugInSupportsMIMEType ? ObjectContentNetscapePlugin : ObjectContentImage;
 719
 720     if (plugInSupportsMIMEType)
 721         return ObjectContentNetscapePlugin;
 722
 723     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
 724         return ObjectContentFrame;
 725
 726     return ObjectContentNone;
 727 }
 728
 729 PassOwnPtr<WebPluginLoadObserver> FrameLoaderClientImpl::pluginLoadObserver(DocumentLoader* loader)
 730 {
 731     return WebDataSourceImpl::fromDocumentLoader(loader)->releasePluginLoadObserver();
 732 }
 733
 734 WebCookieJar* FrameLoaderClientImpl::cookieJar() const
 735 {
 736     if (!m_webFrame->client())
 737         return 0;
 738     return m_webFrame->client()->cookieJar(m_webFrame);
 739 }
 740
 741 bool FrameLoaderClientImpl::willCheckAndDispatchMessageEvent(
 742     SecurityOrigin* target, MessageEvent* event) const
 743 {
 744     if (!m_webFrame->client())
 745         return false;
 746
 747     WebLocalFrame* source = 0;
 748     if (event && event->source() && event->source()->toDOMWindow() && event->source()->toDOMWindow()->document())
 749         source = WebLocalFrameImpl::fromFrame(event->source()->toDOMWindow()->document()->frame());
 750     return m_webFrame->client()->willCheckAndDispatchMessageEvent(
 751         source, m_webFrame, WebSecurityOrigin(target), WebDOMMessageEvent(event));
 752 }
 753
 754 void FrameLoaderClientImpl::didChangeName(const String& name)
 755 {
 756     if (!m_webFrame->client())
 757         return;
 758     m_webFrame->client()->didChangeName(m_webFrame, name);
 759 }
 760
 761 void FrameLoaderClientImpl::dispatchWillOpenSocketStream(SocketStreamHandle* handle)
 762 {
 763     m_webFrame->client()->willOpenSocketStream(SocketStreamHandleInternal::toWebSocketStreamHandle(handle));
 764 }
 765
 766 void FrameLoaderClientImpl::dispatchWillOpenWebSocket(WebSocketHandle* handle)
 767 {
 768     m_webFrame->client()->willOpenWebSocket(handle);
 769 }
 770
 771 void FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler(WebRTCPeerConnectionHandler* handler)
 772 {
 773     m_webFrame->client()->willStartUsingPeerConnectionHandler(webFrame(), handler);
 774 }
 775
 776 void FrameLoaderClientImpl::didRequestAutocomplete(HTMLFormElement* form)
 777 {
 778     if (m_webFrame->viewImpl() && m_webFrame->viewImpl()->autofillClient())
 779         m_webFrame->viewImpl()->autofillClient()->didRequestAutocomplete(WebFormElement(form));
 780 }
 781
 782 bool FrameLoaderClientImpl::allowWebGL(bool enabledPerSettings)
 783 {
 784     if (m_webFrame->client())
 785         return m_webFrame->client()->allowWebGL(m_webFrame, enabledPerSettings);
 786
 787     return enabledPerSettings;
 788 }
 789
 790 void FrameLoaderClientImpl::didLoseWebGLContext(int arbRobustnessContextLostReason)
 791 {
 792     if (m_webFrame->client())
 793         m_webFrame->client()->didLoseWebGLContext(m_webFrame, arbRobustnessContextLostReason);
 794 }
 795
 796 void FrameLoaderClientImpl::dispatchWillInsertBody()
 797 {
 798     if (m_webFrame->client())
 799         m_webFrame->client()->willInsertBody(m_webFrame);
 800
 801     if (m_webFrame->viewImpl())
 802         m_webFrame->viewImpl()->willInsertBody(m_webFrame);
 803 }
 804
 805 PassOwnPtr<WebServiceWorkerProvider> FrameLoaderClientImpl::createServiceWorkerProvider()
 806 {
 807     if (!m_webFrame->client())
 808         return nullptr;
 809     return adoptPtr(m_webFrame->client()->createServiceWorkerProvider(m_webFrame));
 810 }
 811
 812 SharedWorkerRepositoryClient* FrameLoaderClientImpl::sharedWorkerRepositoryClient()
 813 {
 814     return m_webFrame->sharedWorkerRepositoryClient();
 815 }
 816
 817 PassOwnPtr<WebApplicationCacheHost> FrameLoaderClientImpl::createApplicationCacheHost(WebApplicationCacheHostClient* client)
 818 {
 819     if (!m_webFrame->client())
 820         return nullptr;
 821     return adoptPtr(m_webFrame->client()->createApplicationCacheHost(m_webFrame, client));
 822 }
 823
 824 void FrameLoaderClientImpl::didStopAllLoaders()
 825 {
 826     if (m_webFrame->client())
 827         m_webFrame->client()->didAbortLoading(m_webFrame);
 828 }
 829
 830 void FrameLoaderClientImpl::dispatchDidChangeManifest()
 831 {
 832     if (m_webFrame->client())
 833         m_webFrame->client()->didChangeManifest(m_webFrame);
 834 }
 835
 836 } // namespace blink