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