Remove the ENABLE_XSLT compile-time flag.

Source/WebCore/dom/ProcessingInstruction.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2006, 2008, 2009 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,
@@ skipping 29 matching lines @@
 
 inline ProcessingInstruction::ProcessingInstruction(Document* document, const String& target, const String& data)
     : Node(document, CreateOther)
     , m_target(target)
     , m_data(data)
     , m_cachedSheet(0)
     , m_loading(false)
     , m_alternate(false)
     , m_createdByParser(false)
     , m_isCSS(false)
-#if ENABLE(XSLT)
     , m_isXSL(false)
-#endif
 {
     ScriptWrappable::init(this);
 }
 
 PassRefPtr<ProcessingInstruction> ProcessingInstruction::create(Document* document, const String& target, const String& data)
 {
     return adoptRef(new ProcessingInstruction(document, target, data));
 }
 
 ProcessingInstruction::~ProcessingInstruction()
@@ skipping 53 matching lines @@
         bool attrsOk;
         const HashMap<String, String> attrs = parseAttributes(m_data, attrsOk);
         if (!attrsOk)
             return;
         HashMap<String, String>::const_iterator i = attrs.find("type");
         String type;
         if (i != attrs.end())
             type = i->value;
 
         m_isCSS = type.isEmpty() || type == "text/css";
-#if ENABLE(XSLT)
         m_isXSL = (type == "text/xml" || type == "text/xsl" || type == "application/xml" ||
                    type == "application/xhtml+xml" || type == "application/rss+xml" || type == "application/atom+xml");
         if (!m_isCSS && !m_isXSL)
-#else
-        if (!m_isCSS)
-#endif
             return;
 
         String href = attrs.get("href");
         String alternate = attrs.get("alternate");
         m_alternate = alternate == "yes";
         m_title = attrs.get("title");
         m_media = attrs.get("media");
 
         if (m_alternate && m_title.isEmpty())
             return;
 
         if (href.length() > 1 && href[0] == '#') {
             m_localHref = href.substring(1);
-#if ENABLE(XSLT)
             // We need to make a synthetic XSLStyleSheet that is embedded.  It needs to be able
             // to kick off import/include loads that can hang off some parent sheet.
             if (m_isXSL) {
                 KURL finalURL(ParsedURLString, m_localHref);
                 m_sheet = XSLStyleSheet::createEmbedded(this, finalURL);
                 m_loading = false;
             }
-#endif
         } else {
             if (m_cachedSheet) {
                 m_cachedSheet->removeClient(this);
                 m_cachedSheet = 0;
             }
             
             String url = document()->completeURL(href).string();
             if (!dispatchBeforeLoadEvent(url))
                 return;
             
             m_loading = true;
             document()->styleSheetCollection()->addPendingSheet();
             
             CachedResourceRequest request(ResourceRequest(document()->completeURL(href)));
-#if ENABLE(XSLT)
             if (m_isXSL)
                 m_cachedSheet = document()->cachedResourceLoader()->requestXSLStyleSheet(request);
             else
-#endif
             {
                 String charset = attrs.get("charset");
                 if (charset.isEmpty())
                     charset = document()->charset();
                 request.setCharset(charset);
 
                 m_cachedSheet = document()->cachedResourceLoader()->requestCSSStyleSheet(request);
             }
             if (m_cachedSheet)
                 m_cachedSheet->addClient(this);
@@ skipping 42 matching lines @@
     cssSheet->setMediaQueries(MediaQuerySet::create(m_media));
 
     m_sheet = cssSheet.release();
 
     // We don't need the cross-origin security check here because we are
     // getting the sheet text in "strict" mode. This enforces a valid CSS MIME
     // type.
     parseStyleSheet(sheet->sheetText(true));
 }
 
-#if ENABLE(XSLT)
 void ProcessingInstruction::setXSLStyleSheet(const String& href, const KURL& baseURL, const String& sheet)
 {
     ASSERT(m_isXSL);
     m_sheet = XSLStyleSheet::create(this, href, baseURL);
     parseStyleSheet(sheet);
 }
-#endif
 
 void ProcessingInstruction::parseStyleSheet(const String& sheet)
 {
     if (m_isCSS)
         static_cast<CSSStyleSheet*>(m_sheet.get())->contents()->parseString(sheet);
-#if ENABLE(XSLT)
     else if (m_isXSL)
         static_cast<XSLStyleSheet*>(m_sheet.get())->parseString(sheet);
-#endif
 
     if (m_cachedSheet)
         m_cachedSheet->removeClient(this);
     m_cachedSheet = 0;
 
     m_loading = false;
 
     if (m_isCSS)
         static_cast<CSSStyleSheet*>(m_sheet.get())->contents()->checkLoaded();
-#if ENABLE(XSLT)
     else if (m_isXSL)
         static_cast<XSLStyleSheet*>(m_sheet.get())->checkLoaded();
-#endif
 }
 
 void ProcessingInstruction::setCSSStyleSheet(PassRefPtr<CSSStyleSheet> sheet)
 {
     ASSERT(!m_cachedSheet);
     ASSERT(!m_loading);
     m_sheet = sheet;
     sheet->setTitle(m_title);
     sheet->setDisabled(m_alternate);
 }
@@ skipping 45 matching lines @@
         document()->styleResolverChanged(DeferRecalcStyle);
 }
 
 void ProcessingInstruction::finishParsingChildren()
 {
     m_createdByParser = false;
     Node::finishParsingChildren();
 }
 
 } // namespace