--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/xml/XSLStyleSheetLibxslt.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,315 @@
+/*
+ * This file is part of the XSL implementation.
+ *
+ * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "XSLStyleSheet.h"
+
+#if ENABLE(XSLT)
+
+#include "Console.h"
+#include "DOMWindow.h"
+#include "DocLoader.h"
+#include "Document.h"
+#include "Frame.h"
+#include "Node.h"
+#include "TransformSource.h"
+#include "XMLDocumentParser.h"
+#include "XMLDocumentParserScope.h"
+#include "XSLImportRule.h"
+#include "XSLTProcessor.h"
+#include "loader.h"
+#include <wtf/text/CString.h>
+
+#include <libxml/uri.h>
+#include <libxslt/xsltutils.h>
+
+#if PLATFORM(MAC)
+#include "SoftLinking.h"
+#endif
+
+#if PLATFORM(MAC)
+SOFT_LINK_LIBRARY(libxslt)
+SOFT_LINK(libxslt, xsltIsBlank, int, (xmlChar *str), (str))
+SOFT_LINK(libxslt, xsltGetNsProp, xmlChar *, (xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace), (node, name, nameSpace))
+SOFT_LINK(libxslt, xsltParseStylesheetDoc, xsltStylesheetPtr, (xmlDocPtr doc), (doc))
+SOFT_LINK(libxslt, xsltLoadStylesheetPI, xsltStylesheetPtr, (xmlDocPtr doc), (doc))
+#endif
+
+namespace WebCore {
+
+XSLStyleSheet::XSLStyleSheet(XSLImportRule* parentRule, const String& originalURL, const KURL& finalURL)
+ : StyleSheet(parentRule, originalURL, finalURL)
+ , m_ownerDocument(0)
+ , m_embedded(false)
+ , m_processed(false) // Child sheets get marked as processed when the libxslt engine has finally seen them.
+ , m_stylesheetDoc(0)
+ , m_stylesheetDocTaken(false)
+ , m_parentStyleSheet(0)
+{
+}
+
+XSLStyleSheet::XSLStyleSheet(Node* parentNode, const String& originalURL, const KURL& finalURL, bool embedded)
+ : StyleSheet(parentNode, originalURL, finalURL)
+ , m_ownerDocument(parentNode->document())
+ , m_embedded(embedded)
+ , m_processed(true) // The root sheet starts off processed.
+ , m_stylesheetDoc(0)
+ , m_stylesheetDocTaken(false)
+ , m_parentStyleSheet(0)
+{
+}
+
+XSLStyleSheet::~XSLStyleSheet()
+{
+ if (!m_stylesheetDocTaken)
+ xmlFreeDoc(m_stylesheetDoc);
+}
+
+bool XSLStyleSheet::isLoading()
+{
+ unsigned len = length();
+ for (unsigned i = 0; i < len; ++i) {
+ StyleBase* rule = item(i);
+ if (rule->isImportRule()) {
+ XSLImportRule* import = static_cast<XSLImportRule*>(rule);
+ if (import->isLoading())
+ return true;
+ }
+ }
+ return false;
+}
+
+void XSLStyleSheet::checkLoaded()
+{
+ if (isLoading())
+ return;
+ if (parent())
+ parent()->checkLoaded();
+ if (ownerNode())
+ ownerNode()->sheetLoaded();
+}
+
+xmlDocPtr XSLStyleSheet::document()
+{
+ if (m_embedded && ownerDocument() && ownerDocument()->transformSource())
+ return (xmlDocPtr)ownerDocument()->transformSource()->platformSource();
+ return m_stylesheetDoc;
+}
+
+void XSLStyleSheet::clearDocuments()
+{
+ m_stylesheetDoc = 0;
+ unsigned len = length();
+ for (unsigned i = 0; i < len; ++i) {
+ StyleBase* rule = item(i);
+ if (rule->isImportRule()) {
+ XSLImportRule* import = static_cast<XSLImportRule*>(rule);
+ if (import->styleSheet())
+ import->styleSheet()->clearDocuments();
+ }
+ }
+}
+
+DocLoader* XSLStyleSheet::docLoader()
+{
+ if (!m_ownerDocument)
+ return 0;
+ return m_ownerDocument->docLoader();
+}
+
+bool XSLStyleSheet::parseString(const String& string, bool)
+{
+ // Parse in a single chunk into an xmlDocPtr
+ const UChar BOM = 0xFEFF;
+ const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char*>(&BOM);
+ if (!m_stylesheetDocTaken)
+ xmlFreeDoc(m_stylesheetDoc);
+ m_stylesheetDocTaken = false;
+
+ Console* console = 0;
+ if (Frame* frame = ownerDocument()->frame())
+ console = frame->domWindow()->console();
+
+ XMLDocumentParserScope scope(docLoader(), XSLTProcessor::genericErrorFunc, XSLTProcessor::parseErrorFunc, console);
+
+ const char* buffer = reinterpret_cast<const char*>(string.characters());
+ int size = string.length() * sizeof(UChar);
+
+ xmlParserCtxtPtr ctxt = xmlCreateMemoryParserCtxt(buffer, size);
+ if (!ctxt)
+ return 0;
+
+ if (m_parentStyleSheet) {
+ // The XSL transform may leave the newly-transformed document
+ // with references to the symbol dictionaries of the style sheet
+ // and any of its children. XML document disposal can corrupt memory
+ // if a document uses more than one symbol dictionary, so we
+ // ensure that all child stylesheets use the same dictionaries as their
+ // parents.
+ xmlDictFree(ctxt->dict);
+ ctxt->dict = m_parentStyleSheet->m_stylesheetDoc->dict;
+ xmlDictReference(ctxt->dict);
+ }
+
+ m_stylesheetDoc = xmlCtxtReadMemory(ctxt, buffer, size,
+ finalURL().string().utf8().data(),
+ BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE",
+ XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_NOWARNING | XML_PARSE_NOCDATA);
+ xmlFreeParserCtxt(ctxt);
+
+ loadChildSheets();
+
+ return m_stylesheetDoc;
+}
+
+void XSLStyleSheet::loadChildSheets()
+{
+ if (!document())
+ return;
+
+ xmlNodePtr stylesheetRoot = document()->children;
+
+ // Top level children may include other things such as DTD nodes, we ignore those.
+ while (stylesheetRoot && stylesheetRoot->type != XML_ELEMENT_NODE)
+ stylesheetRoot = stylesheetRoot->next;
+
+ if (m_embedded) {
+ // We have to locate (by ID) the appropriate embedded stylesheet element, so that we can walk the
+ // import/include list.
+ xmlAttrPtr idNode = xmlGetID(document(), (const xmlChar*)(finalURL().string().utf8().data()));
+ if (!idNode)
+ return;
+ stylesheetRoot = idNode->parent;
+ } else {
+ // FIXME: Need to handle an external URI with a # in it. This is a pretty minor edge case, so we'll deal
+ // with it later.
+ }
+
+ if (stylesheetRoot) {
+ // Walk the children of the root element and look for import/include elements.
+ // Imports must occur first.
+ xmlNodePtr curr = stylesheetRoot->children;
+ while (curr) {
+ if (curr->type != XML_ELEMENT_NODE) {
+ curr = curr->next;
+ continue;
+ }
+ if (IS_XSLT_ELEM(curr) && IS_XSLT_NAME(curr, "import")) {
+ xmlChar* uriRef = xsltGetNsProp(curr, (const xmlChar*)"href", XSLT_NAMESPACE);
+ loadChildSheet(String::fromUTF8((const char*)uriRef));
+ xmlFree(uriRef);
+ } else
+ break;
+ curr = curr->next;
+ }
+
+ // Now handle includes.
+ while (curr) {
+ if (curr->type == XML_ELEMENT_NODE && IS_XSLT_ELEM(curr) && IS_XSLT_NAME(curr, "include")) {
+ xmlChar* uriRef = xsltGetNsProp(curr, (const xmlChar*)"href", XSLT_NAMESPACE);
+ loadChildSheet(String::fromUTF8((const char*)uriRef));
+ xmlFree(uriRef);
+ }
+ curr = curr->next;
+ }
+ }
+}
+
+void XSLStyleSheet::loadChildSheet(const String& href)
+{
+ RefPtr<XSLImportRule> childRule = XSLImportRule::create(this, href);
+ append(childRule);
+ childRule->loadSheet();
+}
+
+xsltStylesheetPtr XSLStyleSheet::compileStyleSheet()
+{
+ // FIXME: Hook up error reporting for the stylesheet compilation process.
+ if (m_embedded)
+ return xsltLoadStylesheetPI(document());
+
+ // xsltParseStylesheetDoc makes the document part of the stylesheet
+ // so we have to release our pointer to it.
+ ASSERT(!m_stylesheetDocTaken);
+ xsltStylesheetPtr result = xsltParseStylesheetDoc(m_stylesheetDoc);
+ if (result)
+ m_stylesheetDocTaken = true;
+ return result;
+}
+
+void XSLStyleSheet::setParentStyleSheet(XSLStyleSheet* parent)
+{
+ m_parentStyleSheet = parent;
+ if (parent)
+ m_ownerDocument = parent->ownerDocument();
+}
+
+xmlDocPtr XSLStyleSheet::locateStylesheetSubResource(xmlDocPtr parentDoc, const xmlChar* uri)
+{
+ bool matchedParent = (parentDoc == document());
+ unsigned len = length();
+ for (unsigned i = 0; i < len; ++i) {
+ StyleBase* rule = item(i);
+ if (rule->isImportRule()) {
+ XSLImportRule* import = static_cast<XSLImportRule*>(rule);
+ XSLStyleSheet* child = import->styleSheet();
+ if (!child)
+ continue;
+ if (matchedParent) {
+ if (child->processed())
+ continue; // libxslt has been given this sheet already.
+
+ // Check the URI of the child stylesheet against the doc URI.
+ // In order to ensure that libxml canonicalized both URLs, we get the original href
+ // string from the import rule and canonicalize it using libxml before comparing it
+ // with the URI argument.
+ CString importHref = import->href().utf8();
+ xmlChar* base = xmlNodeGetBase(parentDoc, (xmlNodePtr)parentDoc);
+ xmlChar* childURI = xmlBuildURI((const xmlChar*)importHref.data(), base);
+ bool equalURIs = xmlStrEqual(uri, childURI);
+ xmlFree(base);
+ xmlFree(childURI);
+ if (equalURIs) {
+ child->markAsProcessed();
+ return child->document();
+ }
+ } else {
+ xmlDocPtr result = import->styleSheet()->locateStylesheetSubResource(parentDoc, uri);
+ if (result)
+ return result;
+ }
+ }
+ }
+
+ return 0;
+}
+
+void XSLStyleSheet::markAsProcessed()
+{
+ ASSERT(!m_processed);
+ ASSERT(!m_stylesheetDocTaken);
+ m_processed = true;
+ m_stylesheetDocTaken = true;
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(XSLT)