src/third_party/WebKit/Source/web/WebDocument.cpp

   1 /*
   2  * Copyright (C) 2009 Google 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 are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "WebDocument.h"
  33
  34 #include "WebAXObject.h"
  35 #include "WebDOMEvent.h"
  36 #include "WebDocumentType.h"
  37 #include "WebElement.h"
  38 #include "WebElementCollection.h"
  39 #include "WebFormElement.h"
  40 #include "WebFrameImpl.h"
  41 #include "WebNodeList.h"
  42 #include "bindings/v8/Dictionary.h"
  43 #include "bindings/v8/ExceptionState.h"
  44 #include "bindings/v8/ScriptState.h"
  45 #include "bindings/v8/ScriptValue.h"
  46 #include "core/accessibility/AXObjectCache.h"
  47 #include "core/css/CSSParserMode.h"
  48 #include "core/css/StyleSheetContents.h"
  49 #include "core/dom/CSSSelectorWatch.h"
  50 #include "core/dom/Document.h"
  51 #include "core/dom/DocumentType.h"
  52 #include "core/dom/Element.h"
  53 #include "core/dom/FullscreenElementStack.h"
  54 #include "core/dom/NodeList.h"
  55 #include "core/dom/StyleEngine.h"
  56 #include "core/html/HTMLAllCollection.h"
  57 #include "core/html/HTMLBodyElement.h"
  58 #include "core/html/HTMLCollection.h"
  59 #include "core/html/HTMLElement.h"
  60 #include "core/html/HTMLFormElement.h"
  61 #include "core/html/HTMLHeadElement.h"
  62 #include "core/loader/DocumentLoader.h"
  63 #include "core/rendering/RenderObject.h"
  64 #include "platform/weborigin/SecurityOrigin.h"
  65 #include "public/platform/WebURL.h"
  66 #include "wtf/PassRefPtr.h"
  67 #include <v8.h>
  68
  69 using namespace WebCore;
  70
  71 namespace blink {
  72
  73 WebURL WebDocument::url() const
  74 {
  75     return constUnwrap<Document>()->url();
  76 }
  77
  78 WebSecurityOrigin WebDocument::securityOrigin() const
  79 {
  80     if (!constUnwrap<Document>())
  81         return WebSecurityOrigin();
  82     return WebSecurityOrigin(constUnwrap<Document>()->securityOrigin());
  83 }
  84
  85 WebString WebDocument::encoding() const
  86 {
  87     return constUnwrap<Document>()->encodingName();
  88 }
  89
  90 WebString WebDocument::contentLanguage() const
  91 {
  92     return constUnwrap<Document>()->contentLanguage();
  93 }
  94
  95 WebString WebDocument::referrer() const
  96 {
  97     return constUnwrap<Document>()->referrer();
  98 }
  99
 100 WebURL WebDocument::openSearchDescriptionURL() const
 101 {
 102     return const_cast<Document*>(constUnwrap<Document>())->openSearchDescriptionURL();
 103 }
 104
 105 WebFrame* WebDocument::frame() const
 106 {
 107     return WebFrameImpl::fromFrame(constUnwrap<Document>()->frame());
 108 }
 109
 110 bool WebDocument::isHTMLDocument() const
 111 {
 112     return constUnwrap<Document>()->isHTMLDocument();
 113 }
 114
 115 bool WebDocument::isXHTMLDocument() const
 116 {
 117     return constUnwrap<Document>()->isXHTMLDocument();
 118 }
 119
 120 bool WebDocument::isPluginDocument() const
 121 {
 122     return constUnwrap<Document>()->isPluginDocument();
 123 }
 124
 125 WebURL WebDocument::baseURL() const
 126 {
 127     return constUnwrap<Document>()->baseURL();
 128 }
 129
 130 WebURL WebDocument::firstPartyForCookies() const
 131 {
 132     return constUnwrap<Document>()->firstPartyForCookies();
 133 }
 134
 135 WebElement WebDocument::documentElement() const
 136 {
 137     return WebElement(constUnwrap<Document>()->documentElement());
 138 }
 139
 140 WebElement WebDocument::body() const
 141 {
 142     return WebElement(constUnwrap<Document>()->body());
 143 }
 144
 145 WebElement WebDocument::head()
 146 {
 147     return WebElement(unwrap<Document>()->head());
 148 }
 149
 150 WebString WebDocument::title() const
 151 {
 152     return WebString(constUnwrap<Document>()->title());
 153 }
 154
 155 WebElementCollection WebDocument::all()
 156 {
 157     return WebElementCollection(unwrap<Document>()->all());
 158 }
 159
 160 void WebDocument::images(WebVector<WebElement>& results)
 161 {
 162     RefPtr<HTMLCollection> images = unwrap<Document>()->images();
 163     size_t sourceLength = images->length();
 164     Vector<WebElement> temp;
 165     temp.reserveCapacity(sourceLength);
 166     for (size_t i = 0; i < sourceLength; ++i) {
 167         Element* element = images->item(i);
 168         if (element && element->isHTMLElement())
 169             temp.append(WebElement(element));
 170     }
 171     results.assign(temp);
 172 }
 173
 174 void WebDocument::forms(WebVector<WebFormElement>& results) const
 175 {
 176     RefPtr<HTMLCollection> forms = const_cast<Document*>(constUnwrap<Document>())->forms();
 177     size_t sourceLength = forms->length();
 178     Vector<WebFormElement> temp;
 179     temp.reserveCapacity(sourceLength);
 180     for (size_t i = 0; i < sourceLength; ++i) {
 181         Element* element = forms->item(i);
 182         // Strange but true, sometimes node can be 0.
 183         if (element && element->isHTMLElement())
 184             temp.append(WebFormElement(toHTMLFormElement(element)));
 185     }
 186     results.assign(temp);
 187 }
 188
 189 WebURL WebDocument::completeURL(const WebString& partialURL) const
 190 {
 191     return constUnwrap<Document>()->completeURL(partialURL);
 192 }
 193
 194 WebElement WebDocument::getElementById(const WebString& id) const
 195 {
 196     return WebElement(constUnwrap<Document>()->getElementById(id));
 197 }
 198
 199 WebNode WebDocument::focusedNode() const
 200 {
 201     return WebNode(constUnwrap<Document>()->focusedElement());
 202 }
 203
 204 WebDocumentType WebDocument::doctype() const
 205 {
 206     return WebDocumentType(constUnwrap<Document>()->doctype());
 207 }
 208
 209 void WebDocument::insertStyleSheet(const WebString& sourceCode)
 210 {
 211     RefPtr<Document> document = unwrap<Document>();
 212     ASSERT(document);
 213     RefPtr<StyleSheetContents> parsedSheet = StyleSheetContents::create(CSSParserContext(*document.get(), 0));
 214     parsedSheet->parseString(sourceCode);
 215     document->styleEngine()->addAuthorSheet(parsedSheet);
 216 }
 217
 218 void WebDocument::watchCSSSelectors(const WebVector<WebString>& webSelectors)
 219 {
 220     RefPtr<Document> document = unwrap<Document>();
 221     Vector<String> selectors;
 222     selectors.append(webSelectors.data(), webSelectors.size());
 223     CSSSelectorWatch::from(*document).watchCSSSelectors(selectors);
 224 }
 225
 226 void WebDocument::cancelFullScreen()
 227 {
 228     if (FullscreenElementStack* fullscreen = FullscreenElementStack::fromIfExists(unwrap<Document>()))
 229         fullscreen->webkitCancelFullScreen();
 230 }
 231
 232 WebElement WebDocument::fullScreenElement() const
 233 {
 234     Element* fullScreenElement = 0;
 235     if (FullscreenElementStack* fullscreen = FullscreenElementStack::fromIfExists(const_cast<WebDocument*>(this)->unwrap<Document>()))
 236         fullScreenElement = fullscreen->webkitCurrentFullScreenElement();
 237     return WebElement(fullScreenElement);
 238 }
 239
 240 WebDOMEvent WebDocument::createEvent(const WebString& eventType)
 241 {
 242     TrackExceptionState exceptionState;
 243     WebDOMEvent event(unwrap<Document>()->createEvent(eventType, exceptionState));
 244     if (exceptionState.hadException())
 245         return WebDOMEvent();
 246     return event;
 247 }
 248
 249 WebReferrerPolicy WebDocument::referrerPolicy() const
 250 {
 251     return static_cast<WebReferrerPolicy>(constUnwrap<Document>()->referrerPolicy());
 252 }
 253
 254 WebElement WebDocument::createElement(const WebString& tagName)
 255 {
 256     TrackExceptionState exceptionState;
 257     WebElement element(unwrap<Document>()->createElement(tagName, exceptionState));
 258     if (exceptionState.hadException())
 259         return WebElement();
 260     return element;
 261 }
 262
 263 WebAXObject WebDocument::accessibilityObject() const
 264 {
 265     const Document* document = constUnwrap<Document>();
 266     return WebAXObject(document->axObjectCache()->getOrCreate(document->renderer()));
 267 }
 268
 269 WebAXObject WebDocument::accessibilityObjectFromID(int axID) const
 270 {
 271     const Document* document = constUnwrap<Document>();
 272     return WebAXObject(document->axObjectCache()->objectFromAXID(axID));
 273 }
 274
 275 WebVector<WebDraggableRegion> WebDocument::draggableRegions() const
 276 {
 277     WebVector<WebDraggableRegion> draggableRegions;
 278     const Document* document = constUnwrap<Document>();
 279     if (document->hasAnnotatedRegions()) {
 280         const Vector<AnnotatedRegionValue>& regions = document->annotatedRegions();
 281         draggableRegions = WebVector<WebDraggableRegion>(regions.size());
 282         for (size_t i = 0; i < regions.size(); i++) {
 283             const AnnotatedRegionValue& value = regions[i];
 284             draggableRegions[i].draggable = value.draggable;
 285             draggableRegions[i].bounds = WebCore::IntRect(value.bounds);
 286         }
 287     }
 288     return draggableRegions;
 289 }
 290
 291 v8::Handle<v8::Value> WebDocument::registerEmbedderCustomElement(const WebString& name, v8::Handle<v8::Value> options, WebExceptionCode& ec)
 292 {
 293     Document* document = unwrap<Document>();
 294     Dictionary dictionary(options, v8::Isolate::GetCurrent());
 295     TrackExceptionState exceptionState;
 296     ScriptValue constructor = document->registerElement(ScriptState::current(), name, dictionary, exceptionState, CustomElement::EmbedderNames);
 297     ec = exceptionState.code();
 298     if (exceptionState.hadException())
 299         return v8::Handle<v8::Value>();
 300     return constructor.v8Value();
 301 }
 302
 303 WebDocument::WebDocument(const PassRefPtr<Document>& elem)
 304     : WebNode(elem)
 305 {
 306 }
 307
 308 WebDocument& WebDocument::operator=(const PassRefPtr<Document>& elem)
 309 {
 310     m_private = elem;
 311     return *this;
 312 }
 313
 314 WebDocument::operator PassRefPtr<Document>() const
 315 {
 316     return toDocument(m_private.get());
 317 }
 318
 319 } // namespace blink