Remove the ENABLE_XSLT compile-time flag.

Source/WebCore/xml/parser/XMLDocumentParserLibxml2.cpp

 /*
  * Copyright (C) 2000 Peter Kelly <pmk@post.com>
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Samuel Weinig <sam@webkit.org>
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Holger Hans Peter Freyther
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
  *
@@ skipping 48 matching lines @@
 #include "XMLDocumentParserScope.h"
 #include <libxml/parser.h>
 #include <libxml/parserInternals.h>
 #include <wtf/text/CString.h>
 #include <wtf/StringExtras.h>
 #include <wtf/Threading.h>
 #include <wtf/UnusedParam.h>
 #include <wtf/Vector.h>
 #include <wtf/unicode/UTF8.h>
 
-#if ENABLE(XSLT)
 #include "XMLTreeViewer.h"
 #include <libxslt/xslt.h>
-#endif
 
 using namespace std;
 
 namespace WebCore {
 
 class PendingCallbacks {
     WTF_MAKE_NONCOPYABLE(PendingCallbacks); WTF_MAKE_FAST_ALLOCATED;
 public:
     ~PendingCallbacks() { }
     static PassOwnPtr<PendingCallbacks> create()
@@ skipping 388 matching lines @@
 
 static int closeFunc(void* context)
 {
     if (context != &globalDescriptor) {
         OffsetBuffer* data = static_cast<OffsetBuffer*>(context);
         delete data;
     }
     return 0;
 }
 
-#if ENABLE(XSLT)
 static void errorFunc(void*, const char*, ...)
 {
     // FIXME: It would be nice to display error messages somewhere.
 }
-#endif
 
 static bool didInit = false;
 
 PassRefPtr<XMLParserContext> XMLParserContext::createStringParser(xmlSAXHandlerPtr handlers, void* userData)
 {
     if (!didInit) {
         xmlInitParser();
         xmlRegisterInputCallbacks(matchFunc, openFunc, readFunc, closeFunc);
         xmlRegisterOutputCallbacks(matchFunc, openFunc, writeFunc, closeFunc);
         libxmlLoaderThread = currentThread();
@@ skipping 484 matching lines @@
     pi->setCreatedByParser(true);
 
     m_currentNode->parserAppendChild(pi.get());
     if (m_view && !pi->attached())
         pi->attach();
 
     pi->finishParsingChildren();
 
     if (pi->isCSS())
         m_sawCSS = true;
-#if ENABLE(XSLT)
     m_sawXSLTransform = !m_sawFirstElement && pi->isXSL();
     if (m_sawXSLTransform && !document()->transformSourceDocument())
         stopParsing();
-#endif
 }
 
 void XMLDocumentParser::cdataBlock(const xmlChar* s, int len)
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks->appendCDATABlockCallback(s, len);
         return;
@@ skipping 344 matching lines @@
             // Tell libxml we're done.
             {
                 XMLDocumentParserScope scope(document()->cachedResourceLoader());
                 xmlParseChunk(context(), 0, 0, 1);
             }
 
             m_context = 0;
         }
     }
 
-#if ENABLE(XSLT)
     XMLTreeViewer xmlTreeViewer(document());
     bool xmlViewerMode = !m_sawError && !m_sawCSS && !m_sawXSLTransform && xmlTreeViewer.hasNoStyleInformation();
     if (xmlViewerMode)
         xmlTreeViewer.transformDocumentToTreeView();
 
     if (m_sawXSLTransform) {
         void* doc = xmlDocPtrForString(document()->cachedResourceLoader(), m_originalSourceForTransform.toString(), document()->url().string());
         document()->setTransformSource(adoptPtr(new TransformSource(doc)));
 
         document()->setParsing(false); // Make the document think it's done, so it will apply XSL stylesheets.
         document()->styleResolverChanged(RecalcStyleImmediately);
 
         // styleResolverChanged() call can detach the parser and null out its document.
         // In that case, we just bail out.
         if (isDetached())
             return;
 
         document()->setParsing(true);
         DocumentParser::stopParsing();
     }
-#endif
 }
 
-#if ENABLE(XSLT)
 void* xmlDocPtrForString(CachedResourceLoader* cachedResourceLoader, const String& source, const String& url)
 {
     if (source.isEmpty())
         return 0;
 
     // Parse in a single chunk into an xmlDocPtr
     // FIXME: Hook up error handlers so that a failure to parse the main document results in
     // good error messages.
     const UChar BOM = 0xFEFF;
     const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char*>(&BOM);
 
     XMLDocumentParserScope scope(cachedResourceLoader, errorFunc, 0);
     xmlDocPtr sourceDoc = xmlReadMemory(reinterpret_cast<const char*>(source.characters()),
                                         source.length() * sizeof(UChar),
                                         url.latin1().data(),
                                         BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE",
                                         XSLT_PARSE_OPTIONS);
     return sourceDoc;
 }
-#endif
 
 OrdinalNumber XMLDocumentParser::lineNumber() const
 {
     return OrdinalNumber::fromOneBasedInt(context() ? context()->input->line : 1);
 }
 
 OrdinalNumber XMLDocumentParser::columnNumber() const
 {
     return OrdinalNumber::fromOneBasedInt(context() ? context()->input->col : 1);
 }
@@ skipping 115 matching lines @@
     sax.startElementNs = attributesStartElementNsHandler;
     sax.initialized = XML_SAX2_MAGIC;
     RefPtr<XMLParserContext> parser = XMLParserContext::createStringParser(&sax, &state);
     String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
     xmlParseChunk(parser->context(), reinterpret_cast<const char*>(parseString.characters()), parseString.length() * sizeof(UChar), 1);
     attrsOK = state.gotAttributes;
     return state.attributes;
 }
 
 }