Source/WebKit/UIProcess/WebFrameProxy.cpp

   1 /*
   2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebFrameProxy.h"
  28
  29 #include "WebCertificateInfo.h"
  30 #include "WebFramePolicyListenerProxy.h"
  31 #include "WebPageMessages.h"
  32 #include "WebPageProxy.h"
  33 #include "WebPasteboardProxy.h"
  34 #include "WebProcessPool.h"
  35 #include <WebCore/Image.h>
  36 #include <WebCore/MIMETypeRegistry.h>
  37 #include <stdio.h>
  38 #include <wtf/text/WTFString.h>
  39
  40 using namespace WebCore;
  41
  42 namespace WebKit {
  43
  44 WebFrameProxy::WebFrameProxy(WebPageProxy* page, uint64_t frameID)
  45     : m_page(page)
  46     , m_isFrameSet(false)
  47     , m_frameID(frameID)
  48 {
  49     WebProcessPool::statistics().wkFrameCount++;
  50 }
  51
  52 WebFrameProxy::~WebFrameProxy()
  53 {
  54     WebProcessPool::statistics().wkFrameCount--;
  55 #if PLATFORM(GTK)
  56     WebPasteboardProxy::singleton().didDestroyFrame(this);
  57 #endif
  58 }
  59
  60 void WebFrameProxy::webProcessWillShutDown()
  61 {
  62     m_page = nullptr;
  63
  64     if (m_activeListener) {
  65         m_activeListener->invalidate();
  66         m_activeListener = nullptr;
  67     }
  68 }
  69
  70 bool WebFrameProxy::isMainFrame() const
  71 {
  72     if (!m_page)
  73         return false;
  74
  75     return this == m_page->mainFrame();
  76 }
  77
  78 void WebFrameProxy::loadURL(const URL& url)
  79 {
  80     if (!m_page)
  81         return;
  82
  83     m_page->process().send(Messages::WebPage::LoadURLInFrame(url, m_frameID), m_page->pageID());
  84 }
  85
  86 void WebFrameProxy::stopLoading() const
  87 {
  88     if (!m_page)
  89         return;
  90
  91     if (!m_page->isValid())
  92         return;
  93
  94     m_page->process().send(Messages::WebPage::StopLoadingFrame(m_frameID), m_page->pageID());
  95 }
  96
  97 bool WebFrameProxy::canProvideSource() const
  98 {
  99     return isDisplayingMarkupDocument();
 100 }
 101
 102 bool WebFrameProxy::canShowMIMEType(const String& mimeType) const
 103 {
 104     if (!m_page)
 105         return false;
 106
 107     return m_page->canShowMIMEType(mimeType);
 108 }
 109
 110 bool WebFrameProxy::isDisplayingStandaloneImageDocument() const
 111 {
 112     return Image::supportsType(m_MIMEType);
 113 }
 114
 115 bool WebFrameProxy::isDisplayingStandaloneMediaDocument() const
 116 {
 117     return MIMETypeRegistry::isSupportedMediaMIMEType(m_MIMEType);
 118 }
 119
 120 bool WebFrameProxy::isDisplayingMarkupDocument() const
 121 {
 122     // FIXME: This should be a call to a single MIMETypeRegistry function; adding a new one if needed.
 123     // FIXME: This is doing case sensitive comparisons on MIME types, should be using ASCII case insensitive instead.
 124     return m_MIMEType == "text/html" || m_MIMEType == "image/svg+xml" || m_MIMEType == "application/x-webarchive" || MIMETypeRegistry::isXMLMIMEType(m_MIMEType);
 125 }
 126
 127 bool WebFrameProxy::isDisplayingPDFDocument() const
 128 {
 129     return MIMETypeRegistry::isPDFOrPostScriptMIMEType(m_MIMEType);
 130 }
 131
 132 void WebFrameProxy::didStartProvisionalLoad(const URL& url)
 133 {
 134     m_provisionalLoadRedirectChain = { url };
 135
 136     m_frameLoadState.didStartProvisionalLoad(url);
 137 }
 138
 139 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const URL& url)
 140 {
 141     // didReceiveServerRedirectForProvisionalLoad() often gets called twice for the same redirect.
 142     if (m_provisionalLoadRedirectChain.isEmpty() || m_provisionalLoadRedirectChain.last() != url)
 143         m_provisionalLoadRedirectChain.append(url);
 144
 145     m_frameLoadState.didReceiveServerRedirectForProvisionalLoad(url);
 146 }
 147
 148 void WebFrameProxy::didFailProvisionalLoad()
 149 {
 150     m_provisionalLoadRedirectChain.clear();
 151     m_frameLoadState.didFailProvisionalLoad();
 152 }
 153
 154 void WebFrameProxy::didCommitLoad(const String& contentType, WebCertificateInfo& certificateInfo, bool containsPluginDocument)
 155 {
 156     m_frameLoadState.didCommitLoad();
 157
 158     m_title = String();
 159     m_MIMEType = contentType;
 160     m_isFrameSet = false;
 161     m_certificateInfo = &certificateInfo;
 162     m_containsPluginDocument = containsPluginDocument;
 163 }
 164
 165 void WebFrameProxy::didFinishLoad()
 166 {
 167     m_provisionalLoadRedirectChain.clear();
 168     m_frameLoadState.didFinishLoad();
 169 }
 170
 171 void WebFrameProxy::didFailLoad()
 172 {
 173     m_provisionalLoadRedirectChain.clear();
 174     m_frameLoadState.didFailLoad();
 175 }
 176
 177 void WebFrameProxy::didSameDocumentNavigation(const URL& url)
 178 {
 179     m_frameLoadState.didSameDocumentNotification(url);
 180 }
 181
 182 void WebFrameProxy::didChangeTitle(const String& title)
 183 {
 184     m_title = title;
 185 }
 186
 187 void WebFrameProxy::receivedPolicyDecision(PolicyAction action, uint64_t listenerID, API::Navigation* navigation, const WebsitePolicies& websitePolicies)
 188 {
 189     if (!m_page)
 190         return;
 191
 192     ASSERT(m_activeListener);
 193     ASSERT(m_activeListener->listenerID() == listenerID);
 194     m_page->receivedPolicyDecision(action, *this, listenerID, navigation, websitePolicies);
 195 }
 196
 197 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
 198 {
 199     if (m_activeListener)
 200         m_activeListener->invalidate();
 201     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
 202     return *static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
 203 }
 204
 205 void WebFrameProxy::getWebArchive(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
 206 {
 207     if (!m_page) {
 208         callbackFunction(nullptr, CallbackBase::Error::Unknown);
 209         return;
 210     }
 211
 212     m_page->getWebArchiveOfFrame(this, WTFMove(callbackFunction));
 213 }
 214
 215 void WebFrameProxy::getMainResourceData(Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
 216 {
 217     if (!m_page) {
 218         callbackFunction(nullptr, CallbackBase::Error::Unknown);
 219         return;
 220     }
 221
 222     m_page->getMainResourceDataOfFrame(this, WTFMove(callbackFunction));
 223 }
 224
 225 void WebFrameProxy::getResourceData(API::URL* resourceURL, Function<void (API::Data*, CallbackBase::Error)>&& callbackFunction)
 226 {
 227     if (!m_page) {
 228         callbackFunction(nullptr, CallbackBase::Error::Unknown);
 229         return;
 230     }
 231
 232     m_page->getResourceDataFromFrame(this, resourceURL, WTFMove(callbackFunction));
 233 }
 234
 235 void WebFrameProxy::setUnreachableURL(const URL& unreachableURL)
 236 {
 237     m_frameLoadState.setUnreachableURL(unreachableURL);
 238 }
 239
 240 #if ENABLE(CONTENT_FILTERING)
 241 bool WebFrameProxy::didHandleContentFilterUnblockNavigation(const ResourceRequest& request)
 242 {
 243     if (!m_contentFilterUnblockHandler.canHandleRequest(request)) {
 244         m_contentFilterUnblockHandler = { };
 245         return false;
 246     }
 247
 248     RefPtr<WebPageProxy> page { m_page };
 249     ASSERT(page);
 250     m_contentFilterUnblockHandler.requestUnblockAsync([page](bool unblocked) {
 251         if (unblocked)
 252             page->reload({ });
 253     });
 254     return true;
 255 }
 256 #endif
 257
 258 #if PLATFORM(GTK)
 259 void WebFrameProxy::collapseSelection()
 260 {
 261     if (!m_page)
 262         return;
 263
 264     m_page->process().send(Messages::WebPage::CollapseSelectionInFrame(m_frameID), m_page->pageID());
 265 }
 266 #endif
 267
 268 } // namespace WebKit