Remove ENABLE(SVG) from bindings/

Source/bindings/v8/CustomElementHelpers.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "bindings/v8/CustomElementHelpers.h"
 
 #include "HTMLNames.h"
+#include "SVGNames.h"
 #include "V8CustomElementConstructor.h"
 #include "V8HTMLElementWrapperFactory.h"
+#include "V8SVGElementWrapperFactory.h"
 #include "bindings/v8/DOMDataStore.h"
 #include "bindings/v8/DOMWrapperWorld.h"
 #include "bindings/v8/ScriptController.h"
 #include "core/dom/CustomElementRegistry.h"
 #include "core/dom/Node.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLUnknownElement.h"
-
-#if ENABLE(SVG)
-#include "V8SVGElementWrapperFactory.h"
-#include "SVGNames.h"
 #include "core/svg/SVGElement.h"
-#endif
 
 namespace WebCore {
 
 v8::Handle<v8::Object> CustomElementHelpers::createWrapper(PassRefPtr<Element> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate, const CreateWrapperFunction& createTypeExtensionUpgradeCandidateWrapper)
 {
     ASSERT(impl);
 
     // The constructor and registered lifecycle callbacks should be visible only from main world.
     // FIXME: This shouldn't be needed once each custom element has its own FunctionTemplate
     // https://bugs.webkit.org/show_bug.cgi?id=108138
@@ skipping 29 matching lines @@
     V8DOMWrapper::associateObjectWithWrapper(impl, typeInfo, wrapper, isolate, WrapperConfiguration::Dependent);
     return wrapper;
 }
 
 v8::Handle<v8::Object> CustomElementHelpers::CreateWrapperFunction::invoke(Element* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate) const
 {
     if (element->isHTMLElement()) {
         if (m_html)
             return m_html(toHTMLElement(element), creationContext, isolate);
         return createV8HTMLFallbackWrapper(toHTMLUnknownElement(toHTMLElement(element)), creationContext, isolate);
-    }
-#if ENABLE(SVG)
-    else if (element->isSVGElement()) {
+    } else if (element->isSVGElement()) {
         if (m_svg)
             return m_svg(toSVGElement(element), creationContext, isolate);
         return createV8SVGFallbackWrapper(toSVGElement(element), creationContext, isolate);
     }
-#endif
+
     ASSERT(0);
     return v8::Handle<v8::Object>();
 }
 
 v8::Handle<v8::Object> CustomElementHelpers::createUpgradeCandidateWrapper(PassRefPtr<Element> element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate, const CreateWrapperFunction& createTypeExtensionUpgradeCandidateWrapper)
 {
     if (CustomElementRegistry::isCustomTagName(element->localName())) {
         if (element->isHTMLElement())
             return createV8HTMLDirectWrapper(toHTMLElement(element.get()), creationContext, isolate);
-    #if ENABLE(SVG)
         else if (element->isSVGElement())
             return createV8SVGDirectWrapper(toSVGElement(element.get()), creationContext, isolate);
-    #endif
         else {
             ASSERT(0);
             return v8::Handle<v8::Object>();
         }
     } else {
         // It's a type extension
         return createTypeExtensionUpgradeCandidateWrapper.invoke(element.get(), creationContext, isolate);
     }
 }
 
@@ skipping 47 matching lines @@
 {
     if (prototype.v8Value().IsEmpty() || !prototype.v8Value()->IsObject())
         return false;
 
     v8::Handle<v8::Object> prototypeObject = v8::Handle<v8::Object>::Cast(prototype.v8Value());
     if (hasValidPrototypeChainFor(prototypeObject, &V8HTMLElement::info, state->context())) {
         namespaceURI = HTMLNames::xhtmlNamespaceURI;
         return true;
     }
 
-#if ENABLE(SVG)
     if (hasValidPrototypeChainFor(prototypeObject, &V8SVGElement::info, state->context())) {
         namespaceURI = SVGNames::svgNamespaceURI;
         return true;
     }
-#endif
 
     if (hasValidPrototypeChainFor(prototypeObject, &V8Element::info, state->context())) {
         namespaceURI = nullAtom;
         return true;
     }
 
     return false;
 }
 
 bool CustomElementHelpers::isFeatureAllowed(ScriptState* state)
@@ skipping 29 matching lines @@
 }
 
 // This can return null. In that case, we should take the element name as its local name.
 const QualifiedName* CustomElementHelpers::findLocalName(v8::Handle<v8::Object> chain)
 {
     WrapperTypeInfo* type = CustomElementHelpers::findWrapperType(chain);
     if (!type)
         return 0;
     if (const QualifiedName* htmlName = findHTMLTagNameOfV8Type(type))
         return htmlName;
-#if ENABLE(SVG)
     if (const QualifiedName* svgName = findSVGTagNameOfV8Type(type))
         return svgName;
-#endif
     return 0;
 }
 
 void CustomElementHelpers::upgradeWrappers(ScriptExecutionContext* executionContext, const HashSet<Element*>& elements, const ScriptValue& prototype)
 {
     if (elements.isEmpty())
         return;
 
     v8::HandleScope handleScope;
     v8::Handle<v8::Context> context = toV8Context(executionContext, mainThreadNormalWorld());
@@ skipping 44 matching lines @@
         return;
     v8::Context::Scope scope(context);
 
     for (size_t i = 0; i < invocations.size(); ++i) {
         ASSERT(executionContext == invocations[i].element()->document());
         invokeReadyCallbackIfNeeded(invocations[i].element(), context);
     }
 }
 
 } // namespace WebCore