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/events/UIEventWithKeyState.h"
  42 #include "core/frame/FrameView.h"
  43 #include "core/frame/Settings.h"
  44 #include "core/html/HTMLMediaElement.h"
  45 #include "core/html/HTMLPlugInElement.h"
  46 #include "core/input/EventHandler.h"
  47 #include "core/layout/HitTestResult.h"
  48 #include "core/loader/DocumentLoader.h"
  49 #include "core/loader/FrameLoadRequest.h"
  50 #include "core/loader/FrameLoader.h"
  51 #include "core/loader/HistoryItem.h"
  52 #include "core/page/Page.h"
  53 #include "core/page/WindowFeatures.h"
  54 #include "modules/device_light/DeviceLightController.h"
  55 #include "modules/device_orientation/DeviceMotionController.h"
  56 #include "modules/device_orientation/DeviceOrientationController.h"
  57 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h"
  58 #include "modules/gamepad/NavigatorGamepad.h"
  59 #include "modules/serviceworkers/NavigatorServiceWorker.h"
  60 #include "modules/storage/DOMWindowStorageController.h"
  61 #include "modules/vr/NavigatorVRDevice.h"
  62 #include "platform/MIMETypeRegistry.h"
  63 #include "platform/RuntimeEnabledFeatures.h"
  64 #include "platform/UserGestureIndicator.h"
  65 #include "platform/exported/WrappedResourceRequest.h"
  66 #include "platform/exported/WrappedResourceResponse.h"
  67 #include "platform/network/HTTPParsers.h"
  68 #include "platform/plugins/PluginData.h"
  69 #include "public/platform/Platform.h"
  70 #include "public/platform/WebApplicationCacheHost.h"
  71 #include "public/platform/WebMimeRegistry.h"
  72 #include "public/platform/WebRTCPeerConnectionHandler.h"
  73 #include "public/platform/WebSecurityOrigin.h"
  74 #include "public/platform/WebServiceWorkerProvider.h"
  75 #include "public/platform/WebServiceWorkerProviderClient.h"
  76 #include "public/platform/WebURL.h"
  77 #include "public/platform/WebURLError.h"
  78 #include "public/platform/WebVector.h"
  79 #include "public/web/WebAutofillClient.h"
  80 #include "public/web/WebContentSettingsClient.h"
  81 #include "public/web/WebDOMEvent.h"
  82 #include "public/web/WebDocument.h"
  83 #include "public/web/WebFormElement.h"
  84 #include "public/web/WebFrameClient.h"
  85 #include "public/web/WebNode.h"
  86 #include "public/web/WebPlugin.h"
  87 #include "public/web/WebPluginParams.h"
  88 #include "public/web/WebViewClient.h"
  89 #include "web/DevToolsEmulator.h"
  90 #include "web/SharedWorkerRepositoryClientImpl.h"
  91 #include "web/WebDataSourceImpl.h"
  92 #include "web/WebDevToolsAgentImpl.h"
  93 #include "web/WebDevToolsFrontendImpl.h"
  94 #include "web/WebLocalFrameImpl.h"
  95 #include "web/WebPluginContainerImpl.h"
  96 #include "web/WebPluginLoadObserver.h"
  97 #include "web/WebViewImpl.h"
  98 #include "wtf/StringExtras.h"
  99 #include "wtf/text/CString.h"
 100 #include "wtf/text/WTFString.h"
 101 #include <v8.h>
 102
 103 namespace blink {
 104
 105 FrameLoaderClientImpl::FrameLoaderClientImpl(WebLocalFrameImpl* frame)
 106     : m_webFrame(frame)
 107 {
 108 }
 109
 110 PassOwnPtrWillBeRawPtr<FrameLoaderClientImpl> FrameLoaderClientImpl::create(WebLocalFrameImpl* frame)
 111 {
 112     return adoptPtrWillBeNoop(new FrameLoaderClientImpl(frame));
 113 }
 114
 115 FrameLoaderClientImpl::~FrameLoaderClientImpl()
 116 {
 117 }
 118
 119 DEFINE_TRACE(FrameLoaderClientImpl)
 120 {
 121     visitor->trace(m_webFrame);
 122     FrameLoaderClient::trace(visitor);
 123 }
 124
 125 void FrameLoaderClientImpl::didCreateNewDocument()
 126 {
 127     if (m_webFrame->client())
 128         m_webFrame->client()->didCreateNewDocument(m_webFrame);
 129 }
 130
 131 void FrameLoaderClientImpl::dispatchDidClearWindowObjectInMainWorld()
 132 {
 133     if (m_webFrame->client()) {
 134         m_webFrame->client()->didClearWindowObject(m_webFrame);
 135         Document* document = m_webFrame->frame()->document();
 136         if (document) {
 137             DeviceMotionController::from(*document);
 138             DeviceOrientationController::from(*document);
 139             if (RuntimeEnabledFeatures::deviceLightEnabled())
 140                 DeviceLightController::from(*document);
 141             NavigatorGamepad::from(*document);
 142             NavigatorServiceWorker::from(*document);
 143             DOMWindowStorageController::from(*document);
 144             if (RuntimeEnabledFeatures::webVREnabled())
 145                 NavigatorVRDevice::from(*document);
 146         }
 147     }
 148     // FIXME: when extensions go out of process, this whole concept stops working.
 149     WebDevToolsFrontendImpl* devToolsFrontend = m_webFrame->top()->isWebLocalFrame() ? toWebLocalFrameImpl(m_webFrame->top())->devToolsFrontend() : nullptr;
 150     if (devToolsFrontend)
 151         devToolsFrontend->didClearWindowObject(m_webFrame);
 152 }
 153
 154 void FrameLoaderClientImpl::documentElementAvailable()
 155 {
 156     if (m_webFrame->client())
 157         m_webFrame->client()->didCreateDocumentElement(m_webFrame);
 158
 159     if (m_webFrame->viewImpl())
 160         m_webFrame->viewImpl()->documentElementAvailable(m_webFrame);
 161 }
 162
 163 void FrameLoaderClientImpl::didCreateScriptContext(v8::Local<v8::Context> context, int extensionGroup, int worldId)
 164 {
 165     if (m_webFrame->client())
 166         m_webFrame->client()->didCreateScriptContext(m_webFrame, context, extensionGroup, worldId);
 167 }
 168
 169 void FrameLoaderClientImpl::willReleaseScriptContext(v8::Local<v8::Context> context, int worldId)
 170 {
 171     if (m_webFrame->client())
 172         m_webFrame->client()->willReleaseScriptContext(m_webFrame, context, worldId);
 173 }
 174
 175 bool FrameLoaderClientImpl::allowScriptExtension(const String& extensionName,
 176                                                  int extensionGroup,
 177                                                  int worldId)
 178 {
 179     if (m_webFrame->contentSettingsClient())
 180         return m_webFrame->contentSettingsClient()->allowScriptExtension(extensionName, extensionGroup, worldId);
 181
 182     return true;
 183 }
 184
 185 void FrameLoaderClientImpl::didChangeScrollOffset()
 186 {
 187     if (m_webFrame->client())
 188         m_webFrame->client()->didChangeScrollOffset(m_webFrame);
 189     if (WebViewImpl* webview = m_webFrame->viewImpl())
 190         webview->devToolsEmulator()->viewportChanged();
 191 }
 192
 193 void FrameLoaderClientImpl::didUpdateCurrentHistoryItem()
 194 {
 195     if (m_webFrame->client())
 196         m_webFrame->client()->didUpdateCurrentHistoryItem(m_webFrame);
 197 }
 198
 199 void FrameLoaderClientImpl::didRemoveAllPendingStylesheet()
 200 {
 201     WebViewImpl* webview = m_webFrame->viewImpl();
 202     if (webview)
 203         webview->didRemoveAllPendingStylesheet(m_webFrame);
 204 }
 205
 206 bool FrameLoaderClientImpl::allowScript(bool enabledPerSettings)
 207 {
 208     if (m_webFrame->contentSettingsClient())
 209         return m_webFrame->contentSettingsClient()->allowScript(enabledPerSettings);
 210
 211     return enabledPerSettings;
 212 }
 213
 214 bool FrameLoaderClientImpl::allowScriptFromSource(bool enabledPerSettings, const KURL& scriptURL)
 215 {
 216     if (m_webFrame->contentSettingsClient())
 217         return m_webFrame->contentSettingsClient()->allowScriptFromSource(enabledPerSettings, scriptURL);
 218
 219     return enabledPerSettings;
 220 }
 221
 222 bool FrameLoaderClientImpl::allowPlugins(bool enabledPerSettings)
 223 {
 224     if (m_webFrame->contentSettingsClient())
 225         return m_webFrame->contentSettingsClient()->allowPlugins(enabledPerSettings);
 226
 227     return enabledPerSettings;
 228 }
 229
 230 bool FrameLoaderClientImpl::allowImage(bool enabledPerSettings, const KURL& imageURL)
 231 {
 232     if (m_webFrame->contentSettingsClient())
 233         return m_webFrame->contentSettingsClient()->allowImage(enabledPerSettings, imageURL);
 234
 235     return enabledPerSettings;
 236 }
 237
 238 bool FrameLoaderClientImpl::allowMedia(const KURL& mediaURL)
 239 {
 240     if (m_webFrame->contentSettingsClient())
 241         return m_webFrame->contentSettingsClient()->allowMedia(mediaURL);
 242
 243     return true;
 244 }
 245
 246 bool FrameLoaderClientImpl::allowDisplayingInsecureContent(bool enabledPerSettings, SecurityOrigin* context, const KURL& url)
 247 {
 248     if (m_webFrame->contentSettingsClient())
 249         return m_webFrame->contentSettingsClient()->allowDisplayingInsecureContent(enabledPerSettings, WebSecurityOrigin(context), WebURL(url));
 250
 251     return enabledPerSettings;
 252 }
 253
 254 bool FrameLoaderClientImpl::allowRunningInsecureContent(bool enabledPerSettings, SecurityOrigin* context, const KURL& url)
 255 {
 256     if (m_webFrame->contentSettingsClient())
 257         return m_webFrame->contentSettingsClient()->allowRunningInsecureContent(enabledPerSettings, WebSecurityOrigin(context), WebURL(url));
 258
 259     return enabledPerSettings;
 260 }
 261
 262 void FrameLoaderClientImpl::didNotAllowScript()
 263 {
 264     if (m_webFrame->contentSettingsClient())
 265         m_webFrame->contentSettingsClient()->didNotAllowScript();
 266 }
 267
 268 void FrameLoaderClientImpl::didNotAllowPlugins()
 269 {
 270     if (m_webFrame->contentSettingsClient())
 271         m_webFrame->contentSettingsClient()->didNotAllowPlugins();
 272
 273 }
 274
 275 bool FrameLoaderClientImpl::hasWebView() const
 276 {
 277     return m_webFrame->viewImpl();
 278 }
 279
 280 bool FrameLoaderClientImpl::inShadowTree() const
 281 {
 282     return m_webFrame->inShadowTree();
 283 }
 284
 285 Frame* FrameLoaderClientImpl::opener() const
 286 {
 287     return toCoreFrame(m_webFrame->opener());
 288 }
 289
 290 void FrameLoaderClientImpl::setOpener(Frame* opener)
 291 {
 292     WebFrame* openerFrame = WebFrame::fromFrame(opener);
 293     if (m_webFrame->client() && m_webFrame->opener() != openerFrame)
 294         m_webFrame->client()->didChangeOpener(openerFrame);
 295     m_webFrame->setOpener(openerFrame);
 296 }
 297
 298 Frame* FrameLoaderClientImpl::parent() const
 299 {
 300     return toCoreFrame(m_webFrame->parent());
 301 }
 302
 303 Frame* FrameLoaderClientImpl::top() const
 304 {
 305     return toCoreFrame(m_webFrame->top());
 306 }
 307
 308 Frame* FrameLoaderClientImpl::previousSibling() const
 309 {
 310     return toCoreFrame(m_webFrame->previousSibling());
 311 }
 312
 313 Frame* FrameLoaderClientImpl::nextSibling() const
 314 {
 315     return toCoreFrame(m_webFrame->nextSibling());
 316 }
 317
 318 Frame* FrameLoaderClientImpl::firstChild() const
 319 {
 320     return toCoreFrame(m_webFrame->firstChild());
 321 }
 322
 323 Frame* FrameLoaderClientImpl::lastChild() const
 324 {
 325     return toCoreFrame(m_webFrame->lastChild());
 326 }
 327
 328 void FrameLoaderClientImpl::willBeDetached()
 329 {
 330     m_webFrame->willBeDetached();
 331 }
 332
 333 void FrameLoaderClientImpl::detached(FrameDetachType type)
 334 {
 335     // Alert the client that the frame is being detached. This is the last
 336     // chance we have to communicate with the client.
 337     RefPtrWillBeRawPtr<WebLocalFrameImpl> protector(m_webFrame.get());
 338
 339     WebFrameClient* client = m_webFrame->client();
 340     if (!client)
 341         return;
 342
 343     m_webFrame->willDetachParent();
 344
 345     // Signal that no further communication with WebFrameClient should take
 346     // place at this point since we are no longer associated with the Page.
 347     m_webFrame->setClient(0);
 348
 349     client->frameDetached(m_webFrame, static_cast<WebFrameClient::DetachType>(type));
 350     // Clear our reference to LocalFrame at the very end, in case the client
 351     // refers to it.
 352     m_webFrame->setCoreFrame(nullptr);
 353 }
 354
 355 void FrameLoaderClientImpl::dispatchWillSendRequest(
 356     DocumentLoader* loader, unsigned long identifier, ResourceRequest& request,
 357     const ResourceResponse& redirectResponse)
 358 {
 359     // Give the WebFrameClient a crack at the request.
 360     if (m_webFrame->client()) {
 361         WrappedResourceRequest webreq(request);
 362         WrappedResourceResponse webresp(redirectResponse);
 363         m_webFrame->client()->willSendRequest(
 364             m_webFrame, identifier, webreq, webresp);
 365     }
 366 }
 367
 368 void FrameLoaderClientImpl::dispatchDidReceiveResponse(DocumentLoader* loader,
 369                                                        unsigned long identifier,
 370                                                        const ResourceResponse& response)
 371 {
 372     if (m_webFrame->client()) {
 373         WrappedResourceResponse webresp(response);
 374         m_webFrame->client()->didReceiveResponse(m_webFrame, identifier, webresp);
 375     }
 376 }
 377
 378 void FrameLoaderClientImpl::dispatchDidChangeResourcePriority(unsigned long identifier, ResourceLoadPriority priority, int intraPriorityValue)
 379 {
 380     if (m_webFrame->client())
 381         m_webFrame->client()->didChangeResourcePriority(m_webFrame, identifier, static_cast<WebURLRequest::Priority>(priority), intraPriorityValue);
 382 }
 383
 384 // Called when a particular resource load completes
 385 void FrameLoaderClientImpl::dispatchDidFinishLoading(DocumentLoader* loader,
 386                                                     unsigned long identifier)
 387 {
 388     if (m_webFrame->client())
 389         m_webFrame->client()->didFinishResourceLoad(m_webFrame, identifier);
 390 }
 391
 392 void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad(bool documentIsEmpty)
 393 {
 394     if (m_webFrame->client())
 395         m_webFrame->client()->didFinishDocumentLoad(m_webFrame, documentIsEmpty);
 396     if (WebViewImpl* webview = m_webFrame->viewImpl())
 397         webview->didFinishDocumentLoad(m_webFrame);
 398 }
 399
 400 void FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache(const ResourceRequest& request, const ResourceResponse& response)
 401 {
 402     if (m_webFrame->client())
 403         m_webFrame->client()->didLoadResourceFromMemoryCache(m_webFrame, WrappedResourceRequest(request), WrappedResourceResponse(response));
 404 }
 405
 406 void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents()
 407 {
 408     if (m_webFrame->client())
 409         m_webFrame->client()->didHandleOnloadEvents(m_webFrame);
 410 }
 411
 412 void FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad()
 413 {
 414     if (m_webFrame->client())
 415         m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame);
 416 }
 417
 418 void FrameLoaderClientImpl::dispatchDidNavigateWithinPage(HistoryItem* item, HistoryCommitType commitType)
 419 {
 420     bool shouldCreateHistoryEntry = commitType == StandardCommit;
 421     m_webFrame->viewImpl()->didCommitLoad(shouldCreateHistoryEntry, true);
 422     if (m_webFrame->client())
 423         m_webFrame->client()->didNavigateWithinPage(m_webFrame, WebHistoryItem(item), static_cast<WebHistoryCommitType>(commitType));
 424 }
 425
 426 void FrameLoaderClientImpl::dispatchWillClose()
 427 {
 428     if (m_webFrame->client())
 429         m_webFrame->client()->willClose(m_webFrame);
 430 }
 431
 432 void FrameLoaderClientImpl::dispatchDidStartProvisionalLoad(double triggeringEventTime)
 433 {
 434     if (m_webFrame->client())
 435         m_webFrame->client()->didStartProvisionalLoad(m_webFrame, triggeringEventTime);
 436 }
 437
 438 void FrameLoaderClientImpl::dispatchDidReceiveTitle(const String& title)
 439 {
 440     if (m_webFrame->client())
 441         m_webFrame->client()->didReceiveTitle(m_webFrame, title, WebTextDirectionLeftToRight);
 442 }
 443
 444 void FrameLoaderClientImpl::dispatchDidChangeIcons(IconType type)
 445 {
 446     if (m_webFrame->client())
 447         m_webFrame->client()->didChangeIcon(m_webFrame, static_cast<WebIconURL::Type>(type));
 448 }
 449
 450 void FrameLoaderClientImpl::dispatchDidCommitLoad(HistoryItem* item, HistoryCommitType commitType)
 451 {
 452     m_webFrame->viewImpl()->didCommitLoad(commitType == StandardCommit, false);
 453     if (m_webFrame->client())
 454         m_webFrame->client()->didCommitProvisionalLoad(m_webFrame, WebHistoryItem(item), static_cast<WebHistoryCommitType>(commitType));
 455     WebDevToolsAgentImpl* devToolsAgent = WebLocalFrameImpl::fromFrame(m_webFrame->frame()->localFrameRoot())->devToolsAgentImpl();
 456     if (devToolsAgent)
 457         devToolsAgent->didCommitLoadForLocalFrame(m_webFrame->frame());
 458 }
 459
 460 void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
 461     const ResourceError& error, HistoryCommitType commitType)
 462 {
 463     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().provisionalDocumentLoader());
 464     m_webFrame->didFail(error, true, commitType);
 465     if (observer)
 466         observer->didFailLoading(error);
 467 }
 468
 469 void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error, HistoryCommitType commitType)
 470 {
 471     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().documentLoader());
 472     m_webFrame->didFail(error, false, commitType);
 473     if (observer)
 474         observer->didFailLoading(error);
 475
 476     // Don't clear the redirect chain, this will happen in the middle of client
 477     // redirects, and we need the context. The chain will be cleared when the
 478     // provisional load succeeds or fails, not the "real" one.
 479 }
 480
 481 void FrameLoaderClientImpl::dispatchDidFinishLoad()
 482 {
 483     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver(m_webFrame->frame()->loader().documentLoader());
 484
 485     if (m_webFrame->client())
 486         m_webFrame->client()->didFinishLoad(m_webFrame);
 487
 488     if (observer)
 489         observer->didFinishLoading();
 490
 491     // Don't clear the redirect chain, this will happen in the middle of client
 492     // redirects, and we need the context. The chain will be cleared when the
 493     // provisional load succeeds or fails, not the "real" one.
 494 }
 495
 496 void FrameLoaderClientImpl::dispatchDidChangeThemeColor()
 497 {
 498     if (m_webFrame->client())
 499         m_webFrame->client()->didChangeThemeColor();
 500 }
 501
 502 static bool allowCreatingBackgroundTabs()
 503 {
 504
 505     const WebInputEvent* inputEvent = WebViewImpl::currentInputEvent();
 506     if (!inputEvent || (inputEvent->type != WebInputEvent::MouseUp && (inputEvent->type != WebInputEvent::RawKeyDown && inputEvent->type != WebInputEvent::KeyDown)
 507         && inputEvent->type != WebInputEvent::GestureTap))
 508         return false;
 509
 510     unsigned short buttonNumber;
 511     if (WebInputEvent::isMouseEventType(inputEvent->type)) {
 512         const WebMouseEvent* mouseEvent = static_cast<const WebMouseEvent*>(inputEvent);
 513
 514         switch (mouseEvent->button) {
 515         case WebMouseEvent::ButtonLeft:
 516             buttonNumber = 0;
 517             break;
 518         case WebMouseEvent::ButtonMiddle:
 519             buttonNumber = 1;
 520             break;
 521         case WebMouseEvent::ButtonRight:
 522             buttonNumber = 2;
 523             break;
 524         default:
 525             return false;
 526         }
 527     } else {
 528         // The click is simulated when triggering the keypress event.
 529         buttonNumber = 0;
 530     }
 531     bool ctrl = inputEvent->modifiers & WebMouseEvent::ControlKey;
 532     bool shift = inputEvent->modifiers & WebMouseEvent::ShiftKey;
 533     bool alt = inputEvent->modifiers & WebMouseEvent::AltKey;
 534     bool meta = inputEvent->modifiers & WebMouseEvent::MetaKey;
 535
 536     NavigationPolicy userPolicy;
 537     if (!navigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta, &userPolicy))
 538         return false;
 539     return userPolicy == NavigationPolicyNewBackgroundTab;
 540 }
 541
 542 NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(const ResourceRequest& request, DocumentLoader* loader, NavigationPolicy policy)
 543 {
 544     if (!m_webFrame->client())
 545         return NavigationPolicyIgnore;
 546
 547     if (policy == NavigationPolicyNewBackgroundTab && !allowCreatingBackgroundTabs() && !UIEventWithKeyState::newTabModifierSetFromIsolatedWorld())
 548         policy = NavigationPolicyNewForegroundTab;
 549
 550     WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(loader);
 551
 552     WrappedResourceRequest wrappedResourceRequest(request);
 553     WebFrameClient::NavigationPolicyInfo navigationInfo(wrappedResourceRequest);
 554     navigationInfo.frame = m_webFrame;
 555     navigationInfo.extraData = ds->extraData();
 556     navigationInfo.navigationType = ds->navigationType();
 557     navigationInfo.defaultPolicy = static_cast<WebNavigationPolicy>(policy);
 558     navigationInfo.isRedirect = ds->isRedirect();
 559
 560     WebNavigationPolicy webPolicy = m_webFrame->client()->decidePolicyForNavigation(navigationInfo);
 561     return static_cast<NavigationPolicy>(webPolicy);
 562 }
 563
 564 void FrameLoaderClientImpl::dispatchWillSendSubmitEvent(HTMLFormElement* form)
 565 {
 566     if (m_webFrame->client())
 567         m_webFrame->client()->willSendSubmitEvent(m_webFrame, WebFormElement(form));
 568 }
 569
 570 void FrameLoaderClientImpl::dispatchWillSubmitForm(HTMLFormElement* form)
 571 {
 572     if (m_webFrame->client())
 573         m_webFrame->client()->willSubmitForm(m_webFrame, WebFormElement(form));
 574 }
 575
 576 void FrameLoaderClientImpl::didStartLoading(LoadStartType loadStartType)
 577 {
 578     if (m_webFrame->client())
 579         m_webFrame->client()->didStartLoading(loadStartType == NavigationToDifferentDocument);
 580 }
 581
 582 void FrameLoaderClientImpl::progressEstimateChanged(double progressEstimate)
 583 {
 584     if (m_webFrame->client())
 585         m_webFrame->client()->didChangeLoadProgress(progressEstimate);
 586 }
 587
 588 void FrameLoaderClientImpl::didStopLoading()
 589 {
 590     if (m_webFrame->client())
 591         m_webFrame->client()->didStopLoading();
 592 }
 593
 594 void FrameLoaderClientImpl::loadURLExternally(const ResourceRequest& request, NavigationPolicy policy, const String& suggestedName)
 595 {
 596     if (m_webFrame->client()) {
 597         ASSERT(m_webFrame->frame()->document());
 598         Fullscreen::fullyExitFullscreen(*m_webFrame->frame()->document());
 599         WrappedResourceRequest webreq(request);
 600         m_webFrame->client()->loadURLExternally(
 601             m_webFrame, webreq, static_cast<WebNavigationPolicy>(policy), suggestedName);
 602     }
 603 }
 604
 605 bool FrameLoaderClientImpl::navigateBackForward(int offset) const
 606 {
 607     WebViewImpl* webview = m_webFrame->viewImpl();
 608     if (!webview->client())
 609         return false;
 610
 611     ASSERT(offset);
 612     if (offset > webview->client()->historyForwardListCount())
 613         return false;
 614     if (offset < -webview->client()->historyBackListCount())
 615         return false;
 616     webview->client()->navigateBackForwardSoon(offset);
 617     return true;
 618 }
 619
 620 void FrameLoaderClientImpl::didAccessInitialDocument()
 621 {
 622     if (m_webFrame->client())
 623         m_webFrame->client()->didAccessInitialDocument(m_webFrame);
 624 }
 625
 626 void FrameLoaderClientImpl::didDisplayInsecureContent()
 627 {
 628     if (m_webFrame->client())
 629         m_webFrame->client()->didDisplayInsecureContent(m_webFrame);
 630 }
 631
 632 void FrameLoaderClientImpl::didRunInsecureContent(SecurityOrigin* origin, const KURL& insecureURL)
 633 {
 634     if (m_webFrame->client())
 635         m_webFrame->client()->didRunInsecureContent(m_webFrame, WebSecurityOrigin(origin), insecureURL);
 636 }
 637
 638 void FrameLoaderClientImpl::didDetectXSS(const KURL& insecureURL, bool didBlockEntirePage)
 639 {
 640     if (m_webFrame->client())
 641         m_webFrame->client()->didDetectXSS(m_webFrame, insecureURL, didBlockEntirePage);
 642 }
 643
 644 void FrameLoaderClientImpl::didDispatchPingLoader(const KURL& url)
 645 {
 646     if (m_webFrame->client())
 647         m_webFrame->client()->didDispatchPingLoader(m_webFrame, url);
 648 }
 649
 650 void FrameLoaderClientImpl::didChangePerformanceTiming()
 651 {
 652     if (m_webFrame->client())
 653         m_webFrame->client()->didChangePerformanceTiming();
 654 }
 655
 656 void FrameLoaderClientImpl::selectorMatchChanged(const Vector<String>& addedSelectors, const Vector<String>& removedSelectors)
 657 {
 658     if (WebFrameClient* client = m_webFrame->client())
 659         client->didMatchCSS(m_webFrame, WebVector<WebString>(addedSelectors), WebVector<WebString>(removedSelectors));
 660 }
 661
 662 PassRefPtrWillBeRawPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
 663 {
 664     RefPtrWillBeRawPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(frame, request, data);
 665     if (m_webFrame->client())
 666         m_webFrame->client()->didCreateDataSource(m_webFrame, ds.get());
 667     return ds.release();
 668 }
 669
 670 String FrameLoaderClientImpl::userAgent(const KURL& url)
 671 {
 672     WebString override = m_webFrame->client()->userAgentOverride(m_webFrame, WebURL(url));
 673     if (!override.isEmpty())
 674         return override;
 675
 676     return Platform::current()->userAgent();
 677 }
 678
 679 String FrameLoaderClientImpl::doNotTrackValue()
 680 {
 681     WebString doNotTrack = m_webFrame->client()->doNotTrackValue(m_webFrame);
 682     if (!doNotTrack.isEmpty())
 683         return doNotTrack;
 684     return String();
 685 }
 686
 687 // Called when the FrameLoader goes into a state in which a new page load
 688 // will occur.
 689 void FrameLoaderClientImpl::transitionToCommittedForNewPage()
 690 {
 691     m_webFrame->createFrameView();
 692 }
 693
 694 PassRefPtrWillBeRawPtr<LocalFrame> FrameLoaderClientImpl::createFrame(
 695     const FrameLoadRequest& request,
 696     const AtomicString& name,
 697     HTMLFrameOwnerElement* ownerElement)
 698 {
 699     return m_webFrame->createChildFrame(request, name, ownerElement);
 700 }
 701
 702 bool FrameLoaderClientImpl::canCreatePluginWithoutRenderer(const String& mimeType) const
 703 {
 704     if (!m_webFrame->client())
 705         return false;
 706
 707     return m_webFrame->client()->canCreatePluginWithoutRenderer(mimeType);
 708 }
 709
 710 PassRefPtrWillBeRawPtr<Widget> FrameLoaderClientImpl::createPlugin(
 711     HTMLPlugInElement* element,
 712     const KURL& url,
 713     const Vector<String>& paramNames,
 714     const Vector<String>& paramValues,
 715     const String& mimeType,
 716     bool loadManually,
 717     DetachedPluginPolicy policy)
 718 {
 719     if (!m_webFrame->client())
 720         return nullptr;
 721
 722     WebPluginParams params;
 723     params.url = url;
 724     params.mimeType = mimeType;
 725     params.attributeNames = paramNames;
 726     params.attributeValues = paramValues;
 727     params.loadManually = loadManually;
 728
 729     WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params);
 730     if (!webPlugin)
 731         return nullptr;
 732
 733     // The container takes ownership of the WebPlugin.
 734     RefPtrWillBeRawPtr<WebPluginContainerImpl> container =
 735         WebPluginContainerImpl::create(element, webPlugin);
 736
 737     if (!webPlugin->initialize(container.get())) {
 738 #if ENABLE(OILPAN)
 739         container->dispose();
 740 #endif
 741         return nullptr;
 742     }
 743
 744     if (policy != AllowDetachedPlugin && !element->layoutObject()) {
 745 #if ENABLE(OILPAN)
 746         container->dispose();
 747 #endif
 748         return nullptr;
 749     }
 750
 751     return container;
 752 }
 753
 754 PassOwnPtr<WebMediaPlayer> FrameLoaderClientImpl::createWebMediaPlayer(
 755     HTMLMediaElement& htmlMediaElement,
 756     const WebURL& url,
 757     WebMediaPlayerClient* client)
 758 {
 759     WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(
 760         htmlMediaElement.document().frame());
 761
 762     if (!webFrame || !webFrame->client())
 763         return nullptr;
 764
 765     HTMLMediaElementEncryptedMedia& encryptedMedia = HTMLMediaElementEncryptedMedia::from(htmlMediaElement);
 766     return adoptPtr(webFrame->client()->createMediaPlayer(webFrame, url,
 767         client, &encryptedMedia,
 768         encryptedMedia.contentDecryptionModule()));
 769 }
 770
 771 ObjectContentType FrameLoaderClientImpl::objectContentType(
 772     const KURL& url,
 773     const String& explicitMimeType,
 774     bool shouldPreferPlugInsForImages)
 775 {
 776     // This code is based on Apple's implementation from
 777     // WebCoreSupport/WebFrameBridge.mm.
 778
 779     String mimeType = explicitMimeType;
 780     if (mimeType.isEmpty()) {
 781         // Try to guess the MIME type based off the extension.
 782         String filename = url.lastPathComponent();
 783         int extensionPos = filename.reverseFind('.');
 784         if (extensionPos >= 0) {
 785             String extension = filename.substring(extensionPos + 1);
 786             mimeType = MIMETypeRegistry::getMIMETypeForExtension(extension);
 787             if (mimeType.isEmpty()) {
 788                 // If there's no mimetype registered for the extension, check to see
 789                 // if a plugin can handle the extension.
 790                 mimeType = getPluginMimeTypeFromExtension(extension);
 791             }
 792         }
 793
 794         if (mimeType.isEmpty())
 795             return ObjectContentFrame;
 796     }
 797
 798     // If Chrome is started with the --disable-plugins switch, pluginData is 0.
 799     PluginData* pluginData = m_webFrame->frame()->page()->pluginData();
 800     bool plugInSupportsMIMEType = pluginData && pluginData->supportsMimeType(mimeType);
 801
 802     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
 803         return shouldPreferPlugInsForImages && plugInSupportsMIMEType ? ObjectContentNetscapePlugin : ObjectContentImage;
 804
 805     if (plugInSupportsMIMEType)
 806         return ObjectContentNetscapePlugin;
 807
 808     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
 809         return ObjectContentFrame;
 810
 811     return ObjectContentNone;
 812 }
 813
 814 PassOwnPtr<WebPluginLoadObserver> FrameLoaderClientImpl::pluginLoadObserver(DocumentLoader* loader)
 815 {
 816     return WebDataSourceImpl::fromDocumentLoader(loader)->releasePluginLoadObserver();
 817 }
 818
 819 WebCookieJar* FrameLoaderClientImpl::cookieJar() const
 820 {
 821     if (!m_webFrame->client())
 822         return 0;
 823     return m_webFrame->client()->cookieJar(m_webFrame);
 824 }
 825
 826 bool FrameLoaderClientImpl::willCheckAndDispatchMessageEvent(
 827     SecurityOrigin* target, MessageEvent* event, LocalFrame* sourceFrame) const
 828 {
 829     if (!m_webFrame->client())
 830         return false;
 831     return m_webFrame->client()->willCheckAndDispatchMessageEvent(
 832         WebLocalFrameImpl::fromFrame(sourceFrame), m_webFrame, WebSecurityOrigin(target), WebDOMMessageEvent(event));
 833 }
 834
 835 void FrameLoaderClientImpl::didChangeName(const String& name)
 836 {
 837     if (!m_webFrame->client())
 838         return;
 839     m_webFrame->client()->didChangeName(m_webFrame, name);
 840 }
 841
 842 void FrameLoaderClientImpl::didChangeSandboxFlags(Frame* childFrame, SandboxFlags flags)
 843 {
 844     if (!m_webFrame->client())
 845         return;
 846     m_webFrame->client()->didChangeSandboxFlags(WebFrame::fromFrame(childFrame), static_cast<WebSandboxFlags>(flags));
 847 }
 848
 849 void FrameLoaderClientImpl::dispatchWillOpenWebSocket(WebSocketHandle* handle)
 850 {
 851     m_webFrame->client()->willOpenWebSocket(handle);
 852 }
 853
 854 void FrameLoaderClientImpl::dispatchWillStartUsingPeerConnectionHandler(WebRTCPeerConnectionHandler* handler)
 855 {
 856     m_webFrame->client()->willStartUsingPeerConnectionHandler(webFrame(), handler);
 857 }
 858
 859 void FrameLoaderClientImpl::didRequestAutocomplete(HTMLFormElement* form)
 860 {
 861     if (m_webFrame->autofillClient())
 862         m_webFrame->autofillClient()->didRequestAutocomplete(WebFormElement(form));
 863 }
 864
 865 bool FrameLoaderClientImpl::allowWebGL(bool enabledPerSettings)
 866 {
 867     if (m_webFrame->client())
 868         return m_webFrame->client()->allowWebGL(m_webFrame, enabledPerSettings);
 869
 870     return enabledPerSettings;
 871 }
 872
 873 void FrameLoaderClientImpl::didLoseWebGLContext(int arbRobustnessContextLostReason)
 874 {
 875     if (m_webFrame->client())
 876         m_webFrame->client()->didLoseWebGLContext(m_webFrame, arbRobustnessContextLostReason);
 877 }
 878
 879 void FrameLoaderClientImpl::dispatchWillInsertBody()
 880 {
 881     if (m_webFrame->client())
 882         m_webFrame->client()->willInsertBody(m_webFrame);
 883
 884     if (m_webFrame->viewImpl())
 885         m_webFrame->viewImpl()->willInsertBody(m_webFrame);
 886 }
 887
 888 v8::Local<v8::Value> FrameLoaderClientImpl::createTestInterface(const AtomicString& name)
 889 {
 890     return m_webFrame->createTestInterface(name);
 891 }
 892
 893 PassOwnPtr<WebServiceWorkerProvider> FrameLoaderClientImpl::createServiceWorkerProvider()
 894 {
 895     if (!m_webFrame->client())
 896         return nullptr;
 897     return adoptPtr(m_webFrame->client()->createServiceWorkerProvider(m_webFrame));
 898 }
 899
 900 bool FrameLoaderClientImpl::isControlledByServiceWorker(DocumentLoader& loader)
 901 {
 902     return m_webFrame->client() && m_webFrame->client()->isControlledByServiceWorker(*WebDataSourceImpl::fromDocumentLoader(&loader));
 903 }
 904
 905 int64_t FrameLoaderClientImpl::serviceWorkerID(DocumentLoader& loader)
 906 {
 907     if (!m_webFrame->client())
 908         return -1;
 909     return m_webFrame->client()->serviceWorkerID(*WebDataSourceImpl::fromDocumentLoader(&loader));
 910 }
 911
 912 SharedWorkerRepositoryClient* FrameLoaderClientImpl::sharedWorkerRepositoryClient()
 913 {
 914     return m_webFrame->sharedWorkerRepositoryClient();
 915 }
 916
 917 PassOwnPtr<WebApplicationCacheHost> FrameLoaderClientImpl::createApplicationCacheHost(WebApplicationCacheHostClient* client)
 918 {
 919     if (!m_webFrame->client())
 920         return nullptr;
 921     return adoptPtr(m_webFrame->client()->createApplicationCacheHost(m_webFrame, client));
 922 }
 923
 924 void FrameLoaderClientImpl::didStopAllLoaders()
 925 {
 926     if (m_webFrame->client())
 927         m_webFrame->client()->didAbortLoading(m_webFrame);
 928 }
 929
 930 void FrameLoaderClientImpl::dispatchDidChangeManifest()
 931 {
 932     if (m_webFrame->client())
 933         m_webFrame->client()->didChangeManifest(m_webFrame);
 934 }
 935
 936 unsigned FrameLoaderClientImpl::backForwardLength()
 937 {
 938     WebViewImpl* webview = m_webFrame->viewImpl();
 939     if (!webview || !webview->client())
 940         return 0;
 941     return webview->client()->historyBackListCount() + 1 + webview->client()->historyForwardListCount();
 942 }
 943
 944 void FrameLoaderClientImpl::suddenTerminationDisablerChanged(bool present, SuddenTerminationDisablerType type)
 945 {
 946     if (m_webFrame->client()) {
 947         m_webFrame->client()->suddenTerminationDisablerChanged(
 948             present, static_cast<WebFrameClient::SuddenTerminationDisablerType>(type));
 949     }
 950 }
 951
 952 } // namespace blink