code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit2/UIProcess/WebFrameProxy.cpp

   1 /*
   2  * Copyright (C) 2010 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 "WebContext.h"
  31 #include "WebFormSubmissionListenerProxy.h"
  32 #include "WebFramePolicyListenerProxy.h"
  33 #include "WebPageMessages.h"
  34 #include "WebPageProxy.h"
  35 #include <WebCore/DOMImplementation.h>
  36 #include <WebCore/Image.h>
  37 #include <stdio.h>
  38 #include <wtf/text/WTFString.h>
  39
  40 using namespace WebCore;
  41 using namespace std;
  42
  43 namespace WebKit {
  44
  45 WebFrameProxy::WebFrameProxy(WebPageProxy* page, uint64_t frameID)
  46     : m_page(page)
  47     , m_parentFrame(0)
  48     , m_nextSibling(0)
  49     , m_previousSibling(0)
  50     , m_firstChild(0)
  51     , m_lastChild(0)
  52     , m_loadState(LoadStateFinished)
  53     , m_isFrameSet(false)
  54     , m_frameID(frameID)
  55 {
  56     WebContext::statistics().wkFrameCount++;
  57 }
  58
  59 WebFrameProxy::~WebFrameProxy()
  60 {
  61     WebContext::statistics().wkFrameCount--;
  62 }
  63
  64 void WebFrameProxy::disconnect()
  65 {
  66     m_page = 0;
  67     m_parentFrame = 0;
  68     m_nextSibling = 0;
  69     m_previousSibling = 0;
  70     m_firstChild = 0;
  71     m_lastChild = 0;
  72
  73     if (m_activeListener) {
  74         m_activeListener->invalidate();
  75         m_activeListener = 0;
  76     }
  77 }
  78
  79 bool WebFrameProxy::isMainFrame() const
  80 {
  81     if (!m_page)
  82         return false;
  83
  84     return this == m_page->mainFrame();
  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     if (m_page->canShowMIMEType(mimeType))
 109         return true;
 110
 111 #if PLATFORM(MAC)
 112     // On Mac, we can show PDFs in the main frame.
 113     if (isMainFrame() && !mimeType.isEmpty())
 114         return WebContext::pdfAndPostScriptMIMETypes().contains(mimeType);
 115 #endif
 116
 117     return false;
 118 }
 119
 120 bool WebFrameProxy::isDisplayingStandaloneImageDocument() const
 121 {
 122     return Image::supportsType(m_MIMEType);
 123 }
 124
 125 bool WebFrameProxy::isDisplayingMarkupDocument() const
 126 {
 127     // FIXME: This check should be moved to somewhere in WebCore.
 128     // FIXME: This returns false when displaying a web archive.
 129     return m_MIMEType == "text/html" || m_MIMEType == "image/svg+xml" || DOMImplementation::isXMLMIMEType(m_MIMEType);
 130 }
 131
 132 void WebFrameProxy::didStartProvisionalLoad(const String& url)
 133 {
 134     ASSERT(m_loadState == LoadStateFinished);
 135     ASSERT(m_provisionalURL.isEmpty());
 136     m_loadState = LoadStateProvisional;
 137     m_provisionalURL = url;
 138 }
 139
 140 void WebFrameProxy::didReceiveServerRedirectForProvisionalLoad(const String& url)
 141 {
 142     ASSERT(m_loadState == LoadStateProvisional);
 143     m_provisionalURL = url;
 144 }
 145
 146 void WebFrameProxy::didFailProvisionalLoad()
 147 {
 148     ASSERT(m_loadState == LoadStateProvisional);
 149     m_loadState = LoadStateFinished;
 150     m_provisionalURL = String();
 151     m_unreachableURL = m_lastUnreachableURL;
 152 }
 153
 154 void WebFrameProxy::didCommitLoad(const String& contentType, const PlatformCertificateInfo& certificateInfo)
 155 {
 156     ASSERT(m_loadState == LoadStateProvisional);
 157     m_loadState = LoadStateCommitted;
 158     m_url = m_provisionalURL;
 159     m_provisionalURL = String();
 160     m_title = String();
 161     m_MIMEType = contentType;
 162     m_isFrameSet = false;
 163     m_certificateInfo = WebCertificateInfo::create(certificateInfo);
 164 }
 165
 166 void WebFrameProxy::didFinishLoad()
 167 {
 168     ASSERT(m_loadState == LoadStateCommitted);
 169     ASSERT(m_provisionalURL.isEmpty());
 170     m_loadState = LoadStateFinished;
 171 }
 172
 173 void WebFrameProxy::didFailLoad()
 174 {
 175     ASSERT(m_loadState == LoadStateCommitted);
 176     ASSERT(m_provisionalURL.isEmpty());
 177     m_loadState = LoadStateFinished;
 178     m_title = String();
 179 }
 180
 181 void WebFrameProxy::didSameDocumentNavigation(const String& url)
 182 {
 183     m_url = url;
 184 }
 185
 186 void WebFrameProxy::didChangeTitle(const String& title)
 187 {
 188     m_title = title;
 189 }
 190
 191 void WebFrameProxy::appendChild(WebFrameProxy* child)
 192 {
 193     ASSERT(child->page() == page());
 194     ASSERT(!child->m_parentFrame);
 195     ASSERT(!child->m_nextSibling);
 196     ASSERT(!child->m_previousSibling);
 197
 198     child->m_parentFrame = this;
 199
 200     WebFrameProxy* oldLast = m_lastChild;
 201     m_lastChild = child;
 202
 203     if (oldLast) {
 204         ASSERT(!oldLast->m_nextSibling);
 205         child->m_previousSibling = oldLast;
 206         oldLast->m_nextSibling = child;
 207     } else
 208         m_firstChild = child;
 209 }
 210
 211 void WebFrameProxy::removeChild(WebFrameProxy* child)
 212 {
 213     child->m_parentFrame = 0;
 214
 215     WebFrameProxy*& newLocationForNext = m_firstChild == child ? m_firstChild : child->m_previousSibling->m_nextSibling;
 216     WebFrameProxy*& newLocationForPrevious = m_lastChild == child ? m_lastChild : child->m_nextSibling->m_previousSibling;
 217     swap(newLocationForNext, child->m_nextSibling);
 218     swap(newLocationForPrevious, child->m_previousSibling);
 219     child->m_previousSibling = 0;
 220     child->m_nextSibling = 0;
 221 }
 222
 223 bool WebFrameProxy::isDescendantOf(const WebFrameProxy* ancestor) const
 224 {
 225     if (!ancestor)
 226         return false;
 227
 228     if (m_page != ancestor->m_page)
 229         return false;
 230
 231     for (const WebFrameProxy* frame = this; frame; frame = frame->m_parentFrame) {
 232         if (frame == ancestor)
 233             return true;
 234     }
 235
 236     return false;
 237 }
 238
 239 void WebFrameProxy::dumpFrameTreeToSTDOUT(unsigned indent)
 240 {
 241     if (!indent && m_parentFrame)
 242         printf("NOTE: Printing subtree.\n");
 243
 244     for (unsigned i = 0; i < indent; ++i)
 245         printf(" ");
 246     printf("| FRAME %d %s\n", (int)m_frameID, m_url.utf8().data());
 247
 248     for (WebFrameProxy* child = m_firstChild; child; child = child->m_nextSibling)
 249         child->dumpFrameTreeToSTDOUT(indent + 4);
 250 }
 251
 252 void WebFrameProxy::didRemoveFromHierarchy()
 253 {
 254     if (m_parentFrame)
 255         m_parentFrame->removeChild(this);
 256 }
 257
 258 PassRefPtr<ImmutableArray> WebFrameProxy::childFrames()
 259 {
 260     if (!m_firstChild)
 261         return ImmutableArray::create();
 262
 263     Vector<RefPtr<APIObject> > vector;
 264     for (WebFrameProxy* child = m_firstChild; child; child = child->m_nextSibling)
 265         vector.append(child);
 266
 267     return ImmutableArray::adopt(vector);
 268 }
 269
 270 void WebFrameProxy::receivedPolicyDecision(WebCore::PolicyAction action, uint64_t listenerID)
 271 {
 272     if (!m_page)
 273         return;
 274
 275     ASSERT(m_activeListener);
 276     ASSERT(m_activeListener->listenerID() == listenerID);
 277     m_page->receivedPolicyDecision(action, this, listenerID);
 278 }
 279
 280 WebFramePolicyListenerProxy* WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
 281 {
 282     if (m_activeListener)
 283         m_activeListener->invalidate();
 284     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
 285     return static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
 286 }
 287
 288 WebFormSubmissionListenerProxy* WebFrameProxy::setUpFormSubmissionListenerProxy(uint64_t listenerID)
 289 {
 290     if (m_activeListener)
 291         m_activeListener->invalidate();
 292     m_activeListener = WebFormSubmissionListenerProxy::create(this, listenerID);
 293     return static_cast<WebFormSubmissionListenerProxy*>(m_activeListener.get());
 294 }
 295
 296 void WebFrameProxy::getWebArchive(PassRefPtr<DataCallback> callback)
 297 {
 298     if (!m_page) {
 299         callback->invalidate();
 300         return;
 301     }
 302
 303     m_page->getWebArchiveOfFrame(this, callback);
 304 }
 305
 306 void WebFrameProxy::getMainResourceData(PassRefPtr<DataCallback> callback)
 307 {
 308     if (!m_page) {
 309         callback->invalidate();
 310         return;
 311     }
 312
 313     m_page->getMainResourceDataOfFrame(this, callback);
 314 }
 315
 316 void WebFrameProxy::getResourceData(WebURL* resourceURL, PassRefPtr<DataCallback> callback)
 317 {
 318     if (!m_page) {
 319         callback->invalidate();
 320         return;
 321     }
 322
 323     m_page->getResourceDataFromFrame(this, resourceURL, callback);
 324 }
 325
 326 void WebFrameProxy::setUnreachableURL(const String& unreachableURL)
 327 {
 328     m_lastUnreachableURL = m_unreachableURL;
 329     m_unreachableURL = unreachableURL;
 330 }
 331
 332 } // namespace WebKit