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 "WebFormSubmissionListenerProxy.h"
  31 #include "WebFramePolicyListenerProxy.h"
  32 #include "WebPageMessages.h"
  33 #include "WebPageProxy.h"
  34 #include "WebPasteboardProxy.h"
  35 #include "WebProcessPool.h"
  36 #include <WebCore/Image.h>
  37 #include <WebCore/MIMETypeRegistry.h>
  38 #include <stdio.h>
  39 #include <wtf/text/WTFString.h>
  40
  41 using namespace WebCore;
  42
  43 namespace WebKit {
  44
  45 WebFrameProxy::WebFrameProxy(WebPageProxy* page, uint64_t frameID)
  46     : m_page(page)
  47     , m_isFrameSet(false)
  48     , m_frameID(frameID)
  49 {
  50     WebProcessPool::statistics().wkFrameCount++;
  51 }
  52
  53 WebFrameProxy::~WebFrameProxy()
  54 {
  55     WebProcessPool::statistics().wkFrameCount--;
  56 #if PLATFORM(GTK)
  57     WebPasteboardProxy::singleton().didDestroyFrame(this);
  58 #endif
  59 }
  60
  61 void WebFrameProxy::webProcessWillShutDown()
  62 {
  63     m_page = nullptr;
  64
  65     if (m_activeListener) {
  66         m_activeListener->invalidate();
  67         m_activeListener = nullptr;
  68     }
  69 }
  70
  71 bool WebFrameProxy::isMainFrame() const
  72 {
  73     if (!m_page)
  74         return false;
  75
  76     return this == m_page->mainFrame();
  77 }
  78
  79 void WebFrameProxy::loadURL(const URL& url)
  80 {
  81     if (!m_page)
  82         return;
  83
  84     m_page->process().send(Messages::WebPage::LoadURLInFrame(url, m_frameID), m_page->pageID());
  85 }
  86
  87 void WebFrameProxy::stopLoading() const
  88 {
  89     if (!m_page)
  90         return;
  91
  92     if (!m_page->isValid())
  93         return;
  94
  95     m_page->process().send(Messages::WebPage::StopLoadingFrame(m_frameID), m_page->pageID());
  96 }
  97
  98 bool WebFrameProxy::canProvideSource() const
  99 {
 100     return isDisplayingMarkupDocument();
 101 }
 102
 103 bool WebFrameProxy::canShowMIMEType(const String& mimeType) const
 104 {
 105     if (!m_page)
 106         return false;
 107
 108     return m_page->canShowMIMEType(mimeType);
 109 }
 110
 111 bool WebFrameProxy::isDisplayingStandaloneImageDocument() const
 112 {
 113     return Image::supportsType(m_MIMEType);
 114 }
 115
 116 bool WebFrameProxy::isDisplayingStandaloneMediaDocument() const
 117 {
 118     return MIMETypeRegistry::isSupportedMediaMIMEType(m_MIMEType);
 119 }
 120
 121 bool WebFrameProxy::isDisplayingMarkupDocument() const
 122 {
 123     // FIXME: This should be a call to a single MIMETypeRegistry function; adding a new one if needed.
 124     // FIXME: This is doing case sensitive comparisons on MIME types, should be using ASCII case insensitive instead.
 125     return m_MIMEType == "text/html" || m_MIMEType == "image/svg+xml" || m_MIMEType == "application/x-webarchive" || MIMETypeRegistry::isXMLMIMEType(m_MIMEType);
 126 }
 127
 128 bool WebFrameProxy::isDisplayingPDFDocument() const
 129 {
 130     return MIMETypeRegistry::isPDFOrPostScriptMIMEType(m_MIMEType);
 131 }
 132
 133 void WebFrameProxy::didStartProvisionalLoad(const URL& url)
 134 {
 135     m_frameLoadState.didStartProvisionalLoad(url);
 136 }
 137
 138 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const URL& url)
 139 {
 140     m_frameLoadState.didReceiveServerRedirectForProvisionalLoad(url);
 141 }
 142
 143 void WebFrameProxy::didFailProvisionalLoad()
 144 {
 145     m_frameLoadState.didFailProvisionalLoad();
 146 }
 147
 148 void WebFrameProxy::didCommitLoad(const String& contentType, WebCertificateInfo& certificateInfo, bool containsPluginDocument)
 149 {
 150     m_frameLoadState.didCommitLoad();
 151
 152     m_title = String();
 153     m_MIMEType = contentType;
 154     m_isFrameSet = false;
 155     m_certificateInfo = &certificateInfo;
 156     m_containsPluginDocument = containsPluginDocument;
 157 }
 158
 159 void WebFrameProxy::didFinishLoad()
 160 {
 161     m_frameLoadState.didFinishLoad();
 162 }
 163
 164 void WebFrameProxy::didFailLoad()
 165 {
 166     m_frameLoadState.didFailLoad();
 167 }
 168
 169 void WebFrameProxy::didSameDocumentNavigation(const URL& url)
 170 {
 171     m_frameLoadState.didSameDocumentNotification(url);
 172 }
 173
 174 void WebFrameProxy::didChangeTitle(const String& title)
 175 {
 176     m_title = title;
 177 }
 178
 179 void WebFrameProxy::receivedPolicyDecision(PolicyAction action, uint64_t listenerID, API::Navigation* navigation, const WebsitePolicies& websitePolicies)
 180 {
 181     if (!m_page)
 182         return;
 183
 184     ASSERT(m_activeListener);
 185     ASSERT(m_activeListener->listenerID() == listenerID);
 186     m_page->receivedPolicyDecision(action, *this, listenerID, navigation, websitePolicies);
 187 }
 188
 189 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
 190 {
 191     if (m_activeListener)
 192         m_activeListener->invalidate();
 193     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
 194     return *static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
 195 }
 196
 197 WebFormSubmissionListenerProxy& WebFrameProxy::setUpFormSubmissionListenerProxy(uint64_t listenerID)
 198 {
 199     if (m_activeListener)
 200         m_activeListener->invalidate();
 201     m_activeListener = WebFormSubmissionListenerProxy::create(this, listenerID);
 202     return *static_cast<WebFormSubmissionListenerProxy*>(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