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 2263 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());
-    }
-
     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().");

[philipj_slow, 2015/06/24 11:52:19]

Is an import document also an HTML document? If not it could be included in the
error handling below and afterwards you could ASSERT(!importLoader()) if it's
important.

[Habib Virji, 2015/06/25 13:09:46]

Changed as suggested and it is do important added assert.

[philipj_slow, 2015/06/27 21:42:56]

Can you link to
http://w3c.github.io/webcomponents/spec/imports/#interface-document for these to
make it clear that there is actually a spec for this bit, which I assumed there
wasn't and was happily surprised to find.

[Habib Virji, 2015/06/29 12:17:41]

Done.

+        return;
+    }
+
+    if (isXHTMLDocument()) {

[tkent, 2015/06/23 23:42:17]

Why do you check isXHTMLDocument(), not isXMLDocument()?
What about SVGDocument, ImageDocument, PluginDocument, and MediaDocument?

[philipj_slow, 2015/06/24 11:52:19]

The spec says "If the Document object is not flagged as an HTML document, throw
an InvalidStateError exception and abort these steps." so this ought to be |if
(!isHTMLDocument())| with a message like "Only HTML documents support open()."

[Habib Virji, 2015/06/25 13:09:46]

I find spec in-consistent. 

What you mentioned is do specified in the steps but a note before this step
says:
"Throws an InvalidStateError exception if the Document is an XML document." 

Since !isHTMLDocument() != isXMLDocument() (as explained below), note and steps
are inconsistent. 

[philipj_slow, 2015/06/27 21:42:56]

The note is non-normative, so !isHTMLDocument() is what's actually required by
the spec for open().

[Habib Virji, 2015/06/29 12:17:42]

Done.

+        exceptionState.throwDOMException(InvalidStateError, "XHTML doesn't 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 (isXHTMLDocument()) {

[philipj_slow, 2015/06/24 11:52:19]

Spec says "If the Document object is not flagged as an HTML document, throw an
InvalidStateError exception and abort these steps."

[Habib Virji, 2015/06/25 13:09:47]

Since !isHTMLDocument() != isXMLDocument() (as explained below), note and steps
are inconsistent. 

+        exceptionState.throwDOMException(InvalidStateError, "XHTML doesn't 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 (isXHTMLDocument()) {

[philipj_slow, 2015/06/24 11:52:19]

Here the spec actually says "If the method was invoked on an XML document, throw
an InvalidStateError exception and abort these steps." which would be |if
(isXMLDocument())|. If that's absolutely equivalent to !isHTMLDocument() I would
use that instead for consistency, and if there is some difference we should
probably have the spec changed.

[Habib Virji, 2015/06/25 13:09:46]

isXMLDocument() relies on value of DocumentClass, which is initialized as
XMLDocument when creating the XML document, XMLDocument | XHTMLDocument when
creating a XHTMLDocument and so forth. Same applies for isHTMLDocument(). 

This implies !isHTMLDocument sets DocumentClass only for HTMLDocument and will
imply not be set for XML, SVG, XHTML but also for Image, Plugin and Media. Which
is not the spec says, so have kept isXMLDocument(). 

Spec for write() is consistent with steps and note. So either note for open and
close should be updated or step for write should be updated. 

[philipj_slow, 2015/06/27 21:42:56]

Does write() need to be supported for Image, Plugin or Media documents?

I agree that the spec is inconsistent. What do you think it should say? To me it
seems most sensible to consistently throw for !isHTMLDocument.

[Habib Virji, 2015/06/29 12:17:42]

It should not. I agree it should throw for !isHTMLDocument.

+        exceptionState.throwDOMException(InvalidStateError, "XHTML 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();
 
     if (!hasInsertionPoint && m_ignoreDestructiveWriteCount) {
         addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, ExceptionMessages::failedToExecute("write", "Document", "It isn't possible to write into a document from an asynchronously-loaded external script unless it is explicitly opened.")));
         return;
     }
 
     if (!hasInsertionPoint)
-        open(ownerDocument);
+        open(ownerDocument, exceptionState);

[philipj_slow, 2015/06/24 11:52:19]

It looks like it's impossible for this to throw an exception, so
ASSERT_NO_EXCEPTION? If it were possible, it would also be necessary to handle
it.

[Habib Virji, 2015/06/25 13:09:46]

The reason for adding was it relied on ASSERT_NO_EXCEPTION value as this was
defaultValue for the open(document, exceptionState). With two method one without
parameter, needed to remove default values and this was the only call that was
without exception but with the Document parameter. I have back exceptionState
default in the open with parameter to avoid indicating this will generate an
error. 

 
     ASSERT(m_parser);
     m_parser->insert(text);
 }
 
 void Document::write(const String& text, Document* ownerDocument, ExceptionState& exceptionState)
 {
     write(SegmentedString(text), ownerDocument, exceptionState);
 }
 
 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