Move attributes and methods from HTMLDocument to Document

Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 2264 matching lines @@
     if (!isHTMLDocument())
         return false;
     return isHTMLFrameSetElement(body());
 }
 
 ScriptableDocumentParser* Document::scriptableDocumentParser() const
 {
     return parser() ? parser()->asScriptableDocumentParser() : 0;
 }
 
-void Document::open(Document* ownerDocument, ExceptionState& exceptionState)
+void Document::open()
 {
-    if (importLoader()) {
-        exceptionState.throwDOMException(InvalidStateError, "Imported document doesn't support open().");
-        return;
-    }
-
-    if (ownerDocument) {
-        setURL(ownerDocument->url());
-        m_cookieURL = ownerDocument->cookieURL();
-        setSecurityOrigin(ownerDocument->securityOrigin());
-    }
+    ASSERT(!importLoader());
 
     if (m_frame) {
         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
             if (parser->isParsing()) {
                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
                 if (parser->isExecutingScript())
                     return;
 
                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
                     return;
             }
         }
 
         if (m_frame->loader().provisionalDocumentLoader())
             m_frame->loader().stopAllLoaders();
     }
 
     removeAllEventListenersRecursively();
     implicitOpen(ForceSynchronousParsing);
     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
         parser->setWasCreatedByScript(true);
 
     if (m_frame)
         m_frame->loader().didExplicitOpen();
     if (m_loadEventProgress != LoadEventInProgress && m_loadEventProgress != UnloadEventInProgress)
         m_loadEventProgress = LoadEventNotRun;
 }
 
+void Document::open(Document* ownerDocument, ExceptionState& exceptionState)
+{
+    if (importLoader()) {
+        exceptionState.throwDOMException(InvalidStateError, "Imported document doesn't support open().");
+        return;
+    }
+
+    if (!isHTMLDocument()) {
+        exceptionState.throwDOMException(InvalidStateError, "Only HTML documents support open().");
+        return;
+    }
+
+    if (ownerDocument) {
+        setURL(ownerDocument->url());
+        m_cookieURL = ownerDocument->cookieURL();
+        setSecurityOrigin(ownerDocument->securityOrigin());
+    }
+
+    open();
+}
+
 void Document::detachParser()
 {
     if (!m_parser)
         return;
     m_parser->detach();
     m_parser.clear();
 }
 
 void Document::cancelParsing()
 {
@@ skipping 103 matching lines @@
     if (!rootStyle) {
         rootStyle = rootElement->computedStyle();
         if (!rootStyle)
             return 0;
     }
     if (bodyElement && rootStyle->isOverflowVisible() && isHTMLHtmlElement(*rootElement))
         return bodyElement;
     return rootElement;
 }
 
+void Document::close()
+{
+    if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
+        return;
+
+    explicitClose();
+}
+
 void Document::close(ExceptionState& exceptionState)
 {
     // FIXME: We should follow the specification more closely:
     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
 
     if (importLoader()) {
         exceptionState.throwDOMException(InvalidStateError, "Imported document doesn't support close().");
         return;
     }
 
-    if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
+    if (!isHTMLDocument()) {
+        exceptionState.throwDOMException(InvalidStateError, "Only HTML documents support close().");
         return;
+    }
 
-    explicitClose();
+    close();
 }
 
 void Document::explicitClose()
 {
     if (RefPtrWillBeRawPtr<DocumentParser> parser = m_parser)
         parser->finish();
 
     if (!m_frame) {
         // Because we have no frame, we don't know if all loading has completed,
         // so we just call implicitClose() immediately. FIXME: This might fire
@@ skipping 222 matching lines @@
     return static_cast<int>((currentTime() - m_startTime) * 1000);
 }
 
 void Document::write(const SegmentedString& text, Document* ownerDocument, ExceptionState& exceptionState)
 {
     if (importLoader()) {
         exceptionState.throwDOMException(InvalidStateError, "Imported document doesn't support write().");
         return;
     }
 
+    if (isXMLDocument()) {
+        exceptionState.throwDOMException(InvalidStateError, "XML document doesn't support write().");
+        return;
+    }
+
     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
 
     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
 
     if (m_writeRecursionIsTooDeep)
        return;
 
     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
 
@@ skipping 15 matching lines @@
 }
 
 void Document::writeln(const String& text, Document* ownerDocument, ExceptionState& exceptionState)
 {
     write(text, ownerDocument, exceptionState);
     if (exceptionState.hadException())
         return;
     write("\n", ownerDocument);
 }
 
+void Document::write(LocalDOMWindow* callingWindow, const Vector<String>& text, ExceptionState& exceptionState)
+{
+    ASSERT(callingWindow);
+    StringBuilder builder;
+    for (const String& string : text)
+        builder.append(string);
+    write(builder.toString(), callingWindow->document(), exceptionState);
+}
+
+void Document::writeln(LocalDOMWindow* callingWindow, const Vector<String>& text, ExceptionState& exceptionState)
+{
+    ASSERT(callingWindow);
+    StringBuilder builder;
+    for (const String& string : text)
+        builder.append(string);
+    writeln(builder.toString(), callingWindow->document(), exceptionState);
+}
+
 const KURL& Document::virtualURL() const
 {
     return m_url;
 }
 
 KURL Document::virtualCompleteURL(const String& url) const
 {
     return completeURL(url);
 }
 
@@ skipping 2990 matching lines @@
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     WeakDocumentSet& set = liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().string().utf8().data());
 }
 #endif