1 files changed, 177 insertions, 0 deletions
diff --git a/dom/xslt/xslt/txUnknownHandler.cpp b/dom/xslt/xslt/txUnknownHandler.cpp
new file mode 100644
index 0000000000..7f13418941
--- /dev/null
+++ b/dom/xslt/xslt/txUnknownHandler.cpp
@@ -0,0 +1,177 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txUnknownHandler.h"
+
+#include <utility>
+
+#include "mozilla/UniquePtrExtensions.h"
+#include "nsGkAtoms.h"
+#include "txExecutionState.h"
+#include "txStringUtils.h"
+#include "txStylesheet.h"
+
+using mozilla::UniquePtr;
+using mozilla::WrapUnique;
+
+txUnknownHandler::txUnknownHandler(txExecutionState* aEs)
+    : mEs(aEs), mFlushed(false) {
+  MOZ_COUNT_CTOR_INHERITED(txUnknownHandler, txBufferingHandler);
+}
+
+txUnknownHandler::~txUnknownHandler() {
+  MOZ_COUNT_DTOR_INHERITED(txUnknownHandler, txBufferingHandler);
+}
+
+nsresult txUnknownHandler::attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+                                     nsAtom* aLowercaseLocalName, int32_t aNsID,
+                                     const nsString& aValue) {
+  return mFlushed
+             ? mEs->mResultHandler->attribute(
+                   aPrefix, aLocalName, aLowercaseLocalName, aNsID, aValue)
+             : txBufferingHandler::attribute(
+                   aPrefix, aLocalName, aLowercaseLocalName, aNsID, aValue);
+}
+
+nsresult txUnknownHandler::attribute(nsAtom* aPrefix,
+                                     const nsAString& aLocalName,
+                                     const int32_t aNsID,
+                                     const nsString& aValue) {
+  return mFlushed ? mEs->mResultHandler->attribute(aPrefix, aLocalName, aNsID,
+                                                   aValue)
+                  : txBufferingHandler::attribute(aPrefix, aLocalName, aNsID,
+                                                  aValue);
+}
+
+nsresult txUnknownHandler::characters(const nsAString& aData, bool aDOE) {
+  return mFlushed ? mEs->mResultHandler->characters(aData, aDOE)
+                  : txBufferingHandler::characters(aData, aDOE);
+}
+
+nsresult txUnknownHandler::comment(const nsString& aData) {
+  return mFlushed ? mEs->mResultHandler->comment(aData)
+                  : txBufferingHandler::comment(aData);
+}
+
+nsresult txUnknownHandler::endDocument(nsresult aResult) {
+  if (!mFlushed) {
+    if (NS_FAILED(aResult)) {
+      return NS_OK;
+    }
+
+    // This is an unusual case, no output method has been set and we
+    // didn't create a document element. Switching to XML output mode
+    // anyway.
+
+    // Make sure that mEs->mResultHandler == this is true, otherwise we'll
+    // leak mEs->mResultHandler in createHandlerAndFlush.
+    NS_ASSERTION(mEs->mResultHandler == this,
+                 "We're leaking mEs->mResultHandler.");
+
+    nsresult rv = createHandlerAndFlush(false, u""_ns, kNameSpaceID_None);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return mEs->mResultHandler->endDocument(aResult);
+}
+
+nsresult txUnknownHandler::endElement() {
+  return mFlushed ? mEs->mResultHandler->endElement()
+                  : txBufferingHandler::endElement();
+}
+
+nsresult txUnknownHandler::processingInstruction(const nsString& aTarget,
+                                                 const nsString& aData) {
+  return mFlushed ? mEs->mResultHandler->processingInstruction(aTarget, aData)
+                  : txBufferingHandler::processingInstruction(aTarget, aData);
+}
+
+nsresult txUnknownHandler::startDocument() {
+  return mFlushed ? mEs->mResultHandler->startDocument()
+                  : txBufferingHandler::startDocument();
+}
+
+nsresult txUnknownHandler::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+                                        nsAtom* aLowercaseLocalName,
+                                        int32_t aNsID) {
+  if (!mFlushed) {
+    // Make sure that mEs->mResultHandler == this is true, otherwise we'll
+    // leak mEs->mResultHandler in createHandlerAndFlush.
+    NS_ASSERTION(mEs->mResultHandler == this,
+                 "We're leaking mEs->mResultHandler.");
+
+    RefPtr<nsAtom> owner;
+    if (!aLowercaseLocalName) {
+      owner = TX_ToLowerCaseAtom(aLocalName);
+      NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
+
+      aLowercaseLocalName = owner;
+    }
+
+    bool htmlRoot = aNsID == kNameSpaceID_None && !aPrefix &&
+                    aLowercaseLocalName == nsGkAtoms::html;
+
+    // Use aLocalName and not aLowercaseLocalName in case the output
+    // handler cares about case. For eHTMLOutput the handler will hardcode
+    // to 'html' anyway.
+    nsresult rv = createHandlerAndFlush(
+        htmlRoot, nsDependentAtomString(aLocalName), aNsID);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return mEs->mResultHandler->startElement(aPrefix, aLocalName,
+                                           aLowercaseLocalName, aNsID);
+}
+
+nsresult txUnknownHandler::startElement(nsAtom* aPrefix,
+                                        const nsAString& aLocalName,
+                                        const int32_t aNsID) {
+  if (!mFlushed) {
+    // Make sure that mEs->mResultHandler == this is true, otherwise we'll
+    // leak mEs->mResultHandler in createHandlerAndFlush.
+    NS_ASSERTION(mEs->mResultHandler == this,
+                 "We're leaking mEs->mResultHandler.");
+
+    bool htmlRoot =
+        aNsID == kNameSpaceID_None && !aPrefix &&
+        aLocalName.Equals(u"html"_ns, nsCaseInsensitiveStringComparator);
+    nsresult rv = createHandlerAndFlush(htmlRoot, aLocalName, aNsID);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return mEs->mResultHandler->startElement(aPrefix, aLocalName, aNsID);
+}
+
+nsresult txUnknownHandler::createHandlerAndFlush(bool aHTMLRoot,
+                                                 const nsAString& aName,
+                                                 const int32_t aNsID) {
+  NS_ENSURE_TRUE(mBuffer, NS_ERROR_NOT_INITIALIZED);
+
+  txOutputFormat format;
+  format.merge(*(mEs->mStylesheet->getOutputFormat()));
+  if (format.mMethod == eMethodNotSet) {
+    format.mMethod = aHTMLRoot ? eHTMLOutput : eXMLOutput;
+  }
+
+  UniquePtr<txAXMLEventHandler> handler;
+  nsresult rv = mEs->mOutputHandlerFactory->createHandlerWith(
+      &format, aName, aNsID, getter_Transfers(handler));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mEs->mOutputHandler = handler.get();
+  mEs->mResultHandler = handler.release();
+  // Let the executionstate delete us. We need to stay alive because we might
+  // need to forward hooks to mEs->mResultHandler if someone is currently
+  // flushing a buffer to mEs->mResultHandler.
+  mEs->mObsoleteHandler = WrapUnique(this);
+
+  mFlushed = true;
+
+  // Let go of out buffer as soon as we're done flushing it, we're not going
+  // to need it anymore from this point on (all hooks get forwarded to
+  // mEs->mResultHandler.
+  UniquePtr<txResultBuffer> buffer(std::move(mBuffer));
+  return buffer->flushToHandler(mEs->mResultHandler);
+}