Reviewed by Darin.
authorap <ap@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 29 Oct 2007 17:02:51 +0000 (17:02 +0000)
committerap <ap@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 29 Oct 2007 17:02:51 +0000 (17:02 +0000)
        http://bugs.webkit.org/show_bug.cgi?id=6040
        XSLT does not report errors to the user

        Made parseErrorFunc a static member function of XSLTProcessor to be reusable from XSLStylesheet.
        Switched to xmlSetStructuredErrorFunc to get an error structure instead of pre-formatted console
        output. Got rid of DeprecatedString in XSLTProcessor.

        * dom/Document.cpp:
        (WebCore::Document::applyXSLTransform):
        * xml/XSLStyleSheet.cpp:
        (WebCore::XSLStyleSheet::parseString):
        * xml/XSLTProcessor.cpp:
        (WebCore::XSLTProcessor::parseErrorFunc):
        (WebCore::docLoaderFunc):
        (WebCore::setXSLTLoadCallBack):
        (WebCore::writeToString):
        (WebCore::saveResultToString):
        (WebCore::transformTextStringToXHTMLDocumentString):
        (WebCore::xsltParamArrayFromParameterMap):
        (WebCore::freeXsltParamArray):
        (WebCore::XSLTProcessor::createDocumentFromSource):
        (WebCore::createFragmentFromSource):
        (WebCore::xsltStylesheetPointer):
        (WebCore::xmlDocPtrFromNode):
        (WebCore::resultMIMEType):
        (WebCore::XSLTProcessor::transformToString):
        (WebCore::XSLTProcessor::transformToDocument):
        (WebCore::XSLTProcessor::transformToFragment):
        * xml/XSLTProcessor.h:
        (WebCore::XSLTProcessor::setXSLStylesheet):
        (WebCore::XSLTProcessor::importStylesheet):
        (WebCore::XSLTProcessor::xslStylesheet):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@27227 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebCore/ChangeLog
WebCore/dom/Document.cpp
WebCore/xml/XSLStyleSheet.cpp
WebCore/xml/XSLTProcessor.cpp
WebCore/xml/XSLTProcessor.h

index 603ede94320882d0a0ebfdadbf567eb736921534..b474d6e839da4cddd959935366f8e06a731f8c1f 100644 (file)
@@ -1,3 +1,40 @@
+2007-10-29  Alexey Proskuryakov  <ap@webkit.org>
+
+        Reviewed by Darin.
+
+        http://bugs.webkit.org/show_bug.cgi?id=6040
+        XSLT does not report errors to the user
+
+        Made parseErrorFunc a static member function of XSLTProcessor to be reusable from XSLStylesheet.
+        Switched to xmlSetStructuredErrorFunc to get an error structure instead of pre-formatted console
+        output. Got rid of DeprecatedString in XSLTProcessor.
+
+        * dom/Document.cpp:
+        (WebCore::Document::applyXSLTransform):
+        * xml/XSLStyleSheet.cpp:
+        (WebCore::XSLStyleSheet::parseString):
+        * xml/XSLTProcessor.cpp:
+        (WebCore::XSLTProcessor::parseErrorFunc):
+        (WebCore::docLoaderFunc):
+        (WebCore::setXSLTLoadCallBack):
+        (WebCore::writeToString):
+        (WebCore::saveResultToString):
+        (WebCore::transformTextStringToXHTMLDocumentString):
+        (WebCore::xsltParamArrayFromParameterMap):
+        (WebCore::freeXsltParamArray):
+        (WebCore::XSLTProcessor::createDocumentFromSource):
+        (WebCore::createFragmentFromSource):
+        (WebCore::xsltStylesheetPointer):
+        (WebCore::xmlDocPtrFromNode):
+        (WebCore::resultMIMEType):
+        (WebCore::XSLTProcessor::transformToString):
+        (WebCore::XSLTProcessor::transformToDocument):
+        (WebCore::XSLTProcessor::transformToFragment):
+        * xml/XSLTProcessor.h:
+        (WebCore::XSLTProcessor::setXSLStylesheet):
+        (WebCore::XSLTProcessor::importStylesheet):
+        (WebCore::XSLTProcessor::xslStylesheet):
+
 2007-10-29  Dan Bernstein  <mitz@apple.com>
 
         Reviewed by John Sullivan.
index 2afcf6fbeee7f2491e6e2af998f1b847411b979f..370d1a98c5d5935cd2fab23a1baf982f7022cde8 100644 (file)
@@ -2466,10 +2466,11 @@ void Document::defaultEventHandler(Event *evt)
     if (evt->type() == keydownEvent) {
         KeyboardEvent* kevt = static_cast<KeyboardEvent *>(evt);
 #if PLATFORM(MAC)
-        if (kevt->ctrlKey()) {
+        if (kevt->ctrlKey())
 #else
-        if (kevt->altKey()) {
+        if (kevt->altKey())
 #endif
+        {
             const PlatformKeyboardEvent* ev = kevt->keyEvent();
             String key = (ev ? ev->unmodifiedText() : kevt->keyIdentifier()).lower();
             Element* elem = getElementByAccessKey(key);
@@ -3345,9 +3346,9 @@ void Document::applyXSLTransform(ProcessingInstruction* pi)
     RefPtr<XSLTProcessor> processor = new XSLTProcessor;
     processor->setXSLStylesheet(static_cast<XSLStyleSheet*>(pi->sheet()));
     
-    DeprecatedString resultMIMEType;
-    DeprecatedString newSource;
-    DeprecatedString resultEncoding;
+    String resultMIMEType;
+    String newSource;
+    String resultEncoding;
     if (!processor->transformToString(this, resultMIMEType, newSource, resultEncoding))
         return;
     // FIXME: If the transform failed we should probably report an error (like Mozilla does).
index 43dc929de507bd0706b6ee55a79f526d9aa08861..7abae7e16aa10293b28a215b0534d72988a77563 100644 (file)
 #include "CString.h"
 #include "DocLoader.h"
 #include "Document.h"
-#include "Node.h"
-#include "XSLImportRule.h"
 #include "loader.h"
+#include "Node.h"
+#include "Page.h"
 #include "XMLTokenizer.h"
+#include "XSLImportRule.h"
+#include "XSLTProcessor.h"
+
 #include <libxml/uri.h>
 #include <libxslt/xsltutils.h>
+
 #if PLATFORM(MAC)
 #include "SoftLinking.h"
 #endif
@@ -134,11 +138,20 @@ bool XSLStyleSheet::parseString(const String& string, bool strict)
     if (!m_stylesheetDocTaken)
         xmlFreeDoc(m_stylesheetDoc);
     m_stylesheetDocTaken = false;
+
+    Chrome* chrome = 0;
+    if (Page* page = ownerDocument()->page())
+        chrome = page->chrome();
+    xmlSetStructuredErrorFunc(chrome, XSLTProcessor::parseErrorFunc);
+
     m_stylesheetDoc = xmlReadMemory(reinterpret_cast<const char*>(string.characters()), string.length() * sizeof(UChar),
         m_ownerDocument->URL().ascii(),
         BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE", 
-        XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOCDATA);
+        XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_NOWARNING | XML_PARSE_NOCDATA);
     loadChildSheets();
+
+    xmlSetStructuredErrorFunc(0, 0);
+
     setLoaderForLibXMLCallbacks(0);
     return m_stylesheetDoc;
 }
index 6b82a0c8a4abccc33a3ce31f7e1d47fed5efedd5..8c92d4a9f8ce7395329d0b927246b6a1ad80c4a6 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * This file is part of the XSL implementation.
  *
- * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2005, 2006, 2007 Apple, Inc.
  * Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@webkit.org>
  *
  * This library is free software; you can redistribute it and/or
@@ -36,6 +36,7 @@
 #include "FrameView.h"
 #include "HTMLDocument.h"
 #include "HTMLTokenizer.h"
+#include "Page.h"
 #include "ResourceHandle.h"
 #include "ResourceRequest.h"
 #include "ResourceResponse.h"
@@ -60,8 +61,8 @@ SOFT_LINK_LIBRARY(libxslt);
 SOFT_LINK(libxslt, xsltFreeStylesheet, void, (xsltStylesheetPtr sheet), (sheet))
 SOFT_LINK(libxslt, xsltFreeTransformContext, void, (xsltTransformContextPtr ctxt), (ctxt))
 SOFT_LINK(libxslt, xsltNewTransformContext, xsltTransformContextPtr, (xsltStylesheetPtr style, xmlDocPtr doc), (style, doc))
-SOFT_LINK(libxslt, xsltApplyStylesheetUser, xmlDocPtr, (xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, FILE * profile, xsltTransformContextPtr userCtxt), (style, doc, params, output, profile, userCtxt))
-SOFT_LINK(libxslt, xsltQuoteUserParams, int, (xsltTransformContextPtr ctxt, const char **params), (ctxt, params))
+SOFT_LINK(libxslt, xsltApplyStylesheetUser, xmlDocPtr, (xsltStylesheetPtr style, xmlDocPtr doc, const char** params, const char* output, FILE* profile, xsltTransformContextPtr userCtxt), (style, doc, params, output, profile, userCtxt))
+SOFT_LINK(libxslt, xsltQuoteUserParams, int, (xsltTransformContextPtr ctxt, const char** params), (ctxt, params))
 SOFT_LINK(libxslt, xsltSetLoaderFunc, void, (xsltDocLoaderFunc f), (f))
 SOFT_LINK(libxslt, xsltSaveResultTo, int, (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style), (buf, result, style))
 SOFT_LINK(libxslt, xsltNextImport, xsltStylesheetPtr, (xsltStylesheetPtr style), (style))
@@ -69,28 +70,33 @@ SOFT_LINK(libxslt, xsltNextImport, xsltStylesheetPtr, (xsltStylesheetPtr style),
 
 namespace WebCore {
 
-static void parseErrorFunc(void *ctxt, const char *msg, ...)
+void XSLTProcessor::parseErrorFunc(void* userData, xmlError* error)
 {
-    // FIXME: It would be nice to display error messages somewhere.
-#if !PLATFORM(WIN_OS)
-    // FIXME: No vasprintf support.
-#ifndef ERROR_DISABLED
-    char *errorMessage = 0;
-    va_list args;
-    va_start(args, msg);
-    vasprintf(&errorMessage, msg, args);
-    LOG_ERROR("%s", errorMessage);
-    if (errorMessage)
-        free(errorMessage);
-    va_end(args);
-#endif
-#endif
+    Chrome* chrome = static_cast<Chrome*>(userData);
+    if (!chrome)
+        return;
+
+    MessageLevel level;
+    switch (error->level) {
+        case XML_ERR_NONE:
+            level = TipMessageLevel;
+            break;
+        case XML_ERR_WARNING:
+            level = WarningMessageLevel;
+            break;
+        case XML_ERR_ERROR:
+        case XML_ERR_FATAL:
+            level = ErrorMessageLevel;
+            break;
+    }
+
+    chrome->addMessageToConsole(XMLMessageSource, level, error->message, error->line, error->file);
 }
 
 // FIXME: There seems to be no way to control the ctxt pointer for loading here, thus we have globals.
-static XSLTProcessor *globalProcessor = 0;
-static DocLoader *globalDocLoader = 0;
-static xmlDocPtr docLoaderFunc(const xmlChar *uri,
+static XSLTProcessorglobalProcessor = 0;
+static DocLoaderglobalDocLoader = 0;
+static xmlDocPtr docLoaderFunc(const xmlCharuri,
                                     xmlDictPtr dict,
                                     int options,
                                     void* ctxt,
@@ -102,24 +108,28 @@ static xmlDocPtr docLoaderFunc(const xmlChar *uri,
     switch (type) {
         case XSLT_LOAD_DOCUMENT: {
             xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;
-            xmlChar *base = xmlNodeGetBase(context->document->doc, context->node);
+            xmlCharbase = xmlNodeGetBase(context->document->doc, context->node);
             KURL url((const char*)base, (const char*)uri);
             xmlFree(base);
             ResourceError error;
             ResourceResponse response;
-            xmlGenericErrorFunc oldErrorFunc = xmlGenericError;
-            void *oldErrorContext = xmlGenericErrorContext;
 
             Vector<char> data;
-                
+
             if (globalDocLoader->frame()) 
                 globalDocLoader->frame()->loader()->loadResourceSynchronously(url, error, response, data);
 
-            xmlSetGenericErrorFunc(0, parseErrorFunc);
+            Chrome* chrome = 0;
+            if (Page* page = globalProcessor->xslStylesheet()->ownerDocument()->page())
+                chrome = page->chrome();
+            xmlSetStructuredErrorFunc(chrome, XSLTProcessor::parseErrorFunc);
+
             // We don't specify an encoding here. Neither Gecko nor WinIE respects
             // the encoding specified in the HTTP headers.
             xmlDocPtr doc = xmlReadMemory(data.data(), data.size(), (const char*)uri, 0, options);
-            xmlSetGenericErrorFunc(oldErrorContext, oldErrorFunc);
+
+            xmlSetStructuredErrorFunc(0, 0);
+
             return doc;
         }
         case XSLT_LOAD_STYLESHEET:
@@ -131,27 +141,27 @@ static xmlDocPtr docLoaderFunc(const xmlChar *uri,
     return 0;
 }
 
-static inline void setXSLTLoadCallBack(xsltDocLoaderFunc func, XSLTProcessor *processor, DocLoader *loader)
+static inline void setXSLTLoadCallBack(xsltDocLoaderFunc func, XSLTProcessor* processor, DocLoader* loader)
 {
     xsltSetLoaderFunc(func);
     globalProcessor = processor;
     globalDocLoader = loader;
 }
 
-static int writeToQString(void *context, const char *buffer, int len)
+static int writeToString(void* context, const char* buffer, int len)
 {
-    DeprecatedString &resultOutput = *static_cast<DeprecatedString *>(context);
-    resultOutput += DeprecatedString::fromUtf8(buffer, len);
+    String& resultOutput = *static_cast<String*>(context);
+    resultOutput += String::fromUTF8(buffer, len);
     return len;
 }
 
-static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, DeprecatedString &resultString)
+static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, String& resultString)
 {
     xmlOutputBufferPtr outputBuf = xmlAllocOutputBuffer(0);
     if (!outputBuf)
         return false;
     outputBuf->context = &resultString;
-    outputBuf->writecallback = writeToQString;
+    outputBuf->writecallback = writeToString;
     
     int retval = xsltSaveResultTo(outputBuf, resultDoc, sheet);
     xmlOutputBufferClose(outputBuf);
@@ -159,7 +169,7 @@ static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, Dep
     return (retval >= 0);
 }
 
-static inline void transformTextStringToXHTMLDocumentString(String &text)
+static inline void transformTextStringToXHTMLDocumentString(Stringtext)
 {
     // Modify the output so that it is a well-formed XHTML document with a <pre> tag enclosing the text.
     text.replace('&', "&amp;");
@@ -174,12 +184,12 @@ static inline void transformTextStringToXHTMLDocumentString(String &text)
         "</html>\n";
 }
 
-static const char **xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap& parameters)
+static const char** xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap& parameters)
 {
     if (parameters.isEmpty())
         return 0;
 
-    const char **parameterArray = (const char **)fastMalloc(((parameters.size() * 2) + 1) * sizeof(char *));
+    const char** parameterArray = (const char**)fastMalloc(((parameters.size() * 2) + 1) * sizeof(char*));
 
     XSLTProcessor::ParameterMap::iterator end = parameters.end();
     unsigned index = 0;
@@ -192,22 +202,22 @@ static const char **xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap&
     return parameterArray;
 }
 
-static void freeXsltParamArray(const char **params)
+static void freeXsltParamArray(const char** params)
 {
-    const char **temp = params;
+    const char** temp = params;
     if (!params)
         return;
     
     while (*temp) {
-        free((void *)*(temp++)); // strdup returns malloc'd blocks, so we have to use free() here
-        free((void *)*(temp++));
+        free((void*)*(temp++)); // strdup returns malloc'd blocks, so we have to use free() here
+        free((void*)*(temp++));
     }
     fastFree(params);
 }
 
 
-RefPtr<Document> XSLTProcessor::createDocumentFromSource(const DeprecatedString& sourceString,
-    const DeprecatedString& sourceEncoding, const DeprecatedString& sourceMIMEType, Node* sourceNode, Frame* frame)
+RefPtr<Document> XSLTProcessor::createDocumentFromSource(const String& sourceString,
+    const String& sourceEncoding, const String& sourceMIMEType, Node* sourceNode, Frame* frame)
 {
     RefPtr<Document> ownerDocument = sourceNode->document();
     bool sourceIsDocument = (sourceNode == ownerDocument.get());
@@ -247,7 +257,7 @@ RefPtr<Document> XSLTProcessor::createDocumentFromSource(const DeprecatedString&
     return result;
 }
 
-static inline RefPtr<DocumentFragment> createFragmentFromSource(DeprecatedString sourceString, DeprecatedString sourceMIMEType, Node *sourceNode, Document *outputDoc)
+static inline RefPtr<DocumentFragment> createFragmentFromSource(String sourceString, String sourceMIMEType, Node* sourceNode, Document* outputDoc)
 {
     RefPtr<DocumentFragment> fragment = new DocumentFragment(outputDoc);
     
@@ -266,7 +276,7 @@ static inline RefPtr<DocumentFragment> createFragmentFromSource(DeprecatedString
     return fragment;
 }
 
-static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet> &cachedStylesheet, Node *stylesheetRootNode)
+static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStylesheet, Node* stylesheetRootNode)
 {
     if (!cachedStylesheet && stylesheetRootNode) {
         cachedStylesheet = new XSLStyleSheet(stylesheetRootNode->parent() ? stylesheetRootNode->parent() : stylesheetRootNode, stylesheetRootNode->document()->URL());
@@ -279,7 +289,7 @@ static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet> &cachedStyl
     return cachedStylesheet->compileStyleSheet();
 }
 
-static inline xmlDocPtr xmlDocPtrFromNode(Node *sourceNode, bool &shouldDelete)
+static inline xmlDocPtr xmlDocPtrFromNode(Node* sourceNode, bool& shouldDelete)
 {
     RefPtr<Document> ownerDocument = sourceNode->document();
     bool sourceIsDocument = (sourceNode == ownerDocument.get());
@@ -294,26 +304,26 @@ static inline xmlDocPtr xmlDocPtrFromNode(Node *sourceNode, bool &shouldDelete)
     return sourceDoc;
 }
 
-static inline DeprecatedString resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet)
+static inline String resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet)
 {
     // There are three types of output we need to be able to deal with:
     // HTML (create an HTML document), XML (create an XML document),
     // and text (wrap in a <pre> and create an XML document).
 
-    const xmlChar *resultType = 0;
+    const xmlCharresultType = 0;
     XSLT_GET_IMPORT_PTR(resultType, sheet, method);
     if (resultType == 0 && resultDoc->type == XML_HTML_DOCUMENT_NODE)
-        resultType = (const xmlChar *)"html";
+        resultType = (const xmlChar*)"html";
     
-    if (xmlStrEqual(resultType, (const xmlChar *)"html"))
-        return DeprecatedString("text/html");
-    else if (xmlStrEqual(resultType, (const xmlChar *)"text"))
-        return DeprecatedString("text/plain");
+    if (xmlStrEqual(resultType, (const xmlChar*)"html"))
+        return "text/html";
+    else if (xmlStrEqual(resultType, (const xmlChar*)"text"))
+        return "text/plain";
         
-    return DeprecatedString("application/xml");
+    return "application/xml";
 }
 
-bool XSLTProcessor::transformToString(Node *sourceNode, DeprecatedString &mimeType, DeprecatedString &resultString, DeprecatedString &resultEncoding)
+bool XSLTProcessor::transformToString(Node* sourceNode, String& mimeType, String& resultString, String& resultEncoding)
 {
     RefPtr<Document> ownerDocument = sourceNode->document();
     
@@ -344,7 +354,7 @@ bool XSLTProcessor::transformToString(Node *sourceNode, DeprecatedString &mimeTy
         if (transformContext->globalVars == NULL)
            transformContext->globalVars = xmlHashCreate(20);
 
-        const char **params = xsltParamArrayFromParameterMap(m_parameters);
+        const char** params = xsltParamArrayFromParameterMap(m_parameters);
         xsltQuoteUserParams(transformContext, params);
         xmlDocPtr resultDoc = xsltApplyStylesheetUser(sheet, sourceDoc, 0, 0, 0, transformContext);
         
@@ -356,7 +366,7 @@ bool XSLTProcessor::transformToString(Node *sourceNode, DeprecatedString &mimeTy
         
         if (success = saveResultToString(resultDoc, sheet, resultString)) {
             mimeType = resultMIMEType(resultDoc, sheet);
-            resultEncoding = (char *)resultDoc->encoding;
+            resultEncoding = (char*)resultDoc->encoding;
         }
         xmlFreeDoc(resultDoc);
     }
@@ -369,11 +379,11 @@ bool XSLTProcessor::transformToString(Node *sourceNode, DeprecatedString &mimeTy
     return success;
 }
 
-RefPtr<Document> XSLTProcessor::transformToDocument(Node *sourceNode)
+RefPtr<Document> XSLTProcessor::transformToDocument(NodesourceNode)
 {
-    DeprecatedString resultMIMEType;
-    DeprecatedString resultString;
-    DeprecatedString resultEncoding;
+    String resultMIMEType;
+    String resultString;
+    String resultEncoding;
     if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
         return 0;
     return createDocumentFromSource(resultString, resultEncoding, resultMIMEType, sourceNode, 0);
@@ -381,9 +391,9 @@ RefPtr<Document> XSLTProcessor::transformToDocument(Node *sourceNode)
 
 RefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode, Document* outputDoc)
 {
-    DeprecatedString resultMIMEType;
-    DeprecatedString resultString;
-    DeprecatedString resultEncoding;
+    String resultMIMEType;
+    String resultString;
+    String resultEncoding;
 
     // If the output document is HTML, default to HTML method.
     if (outputDoc->isHTMLDocument())
index e4d100cbecd55cb0f2ee09619ce298bcfa24bad2..60e85a59a82337588d6a801f261ef88e09a22a87 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * This file is part of the XSL implementation.
  *
- * Copyright (C) 2004 Apple Computer, Inc.
+ * Copyright (C) 2004, 2007 Apple, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -41,14 +41,14 @@ class DocumentFragment;
 class XSLTProcessor : public Shared<XSLTProcessor>
 {
 public:
-    void setXSLStylesheet(XSLStyleSheet *styleSheet) { m_stylesheet = styleSheet; }
-    bool transformToString(Node *source, DeprecatedString &resultMIMEType, DeprecatedString &resultString, DeprecatedString &resultEncoding);
-    RefPtr<Document> createDocumentFromSource(const DeprecatedString& source, const DeprecatedString& sourceEncoding, const DeprecatedString& sourceMIMEType, Node* sourceNode, Frame* frame);
+    void setXSLStylesheet(XSLStyleSheetstyleSheet) { m_stylesheet = styleSheet; }
+    bool transformToString(Node* source, String& resultMIMEType, String& resultString, String& resultEncoding);
+    RefPtr<Document> createDocumentFromSource(const String& source, const String& sourceEncoding, const String& sourceMIMEType, Node* sourceNode, Frame* frame);
     
     // DOM methods
-    void importStylesheet(Node *style) { m_stylesheetRootNode = style; }
-    RefPtr<DocumentFragment> transformToFragment(Node *source, Document *ouputDoc);
-    RefPtr<Document> transformToDocument(Node *source);
+    void importStylesheet(Nodestyle) { m_stylesheetRootNode = style; }
+    RefPtr<DocumentFragment> transformToFragment(Node* source, Document* ouputDoc);
+    RefPtr<Document> transformToDocument(Nodesource);
     
     void setParameter(const String& namespaceURI, const String& localName, const String& value);
     String getParameter(const String& namespaceURI, const String& localName) const;
@@ -56,16 +56,18 @@ public:
     void clearParameters() { m_parameters.clear(); }
 
     void reset() { m_stylesheet = NULL; m_stylesheetRootNode = NULL;  m_parameters.clear(); }
-    
+
+    static void parseErrorFunc(void* userData, xmlError*);
+
 public:
     // Only for libXSLT callbacks
-    XSLStyleSheet *xslStylesheet() const { return m_stylesheet.get(); }
+    XSLStyleSheetxslStylesheet() const { return m_stylesheet.get(); }
     
     typedef HashMap<String, String> ParameterMap;
 
 private:
     // Convert a libxml doc ptr to a KHTML DOM Document
-    RefPtr<Document> documentFromXMLDocPtr(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, Document *ownerDocument, bool sourceIsDocument);
+    RefPtr<Document> documentFromXMLDocPtr(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, DocumentownerDocument, bool sourceIsDocument);
 
     RefPtr<XSLStyleSheet> m_stylesheet;
     RefPtr<Node> m_stylesheetRootNode;