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