Never create HTMLTrackElement when VideoTrack is not enabled

Source/build/scripts/templates/ElementWrapperFactory.cpp.tmpl

 {% from "macros.tmpl" import license -%}
 {{ license() }}
 
 #include "config.h"
 #include "V8{{namespace}}ElementWrapperFactory.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "{{namespace}}Names.h"
 #include "bindings/v8/CustomElementWrapper.h"
 {%- for tag in tags|sort if tag.has_js_interface %}
@@ skipping 16 matching lines @@
 
 static v8::Handle<v8::Object> create{{namespace}}ElementWrapper({{namespace}}Element*, v8::Handle<v8::Object>, v8::Isolate*)
 {
     ASSERT_NOT_REACHED();
     return v8::Handle<v8::Object>();
 }
 
 {%- for js_interface, list in tags|sort|selectattr('has_js_interface')|groupby('js_interface') %}
 static v8::Handle<v8::Object> create{{js_interface}}Wrapper({{namespace}}Element* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
-{%- if list[0].wrapperOnlyIfMediaIsAvailable %}
-    Settings* settings = element->document().settings();
-    if (!RuntimeEnabledFeatures::mediaEnabled() || (settings && !settings->mediaEnabled()))
+{%- if list[0].contextConditional %}
+    if (!ContextFeatures::{{list[0].contextConditional}}Enabled(&element->document()))
         return createV8{{namespace}}FallbackWrapper(to{{fallback_js_interface}}(element), creationContext, isolate);
 {%- endif %}
-{%- if list[0].contextConditional %}
-    if (!ContextFeatures::{{list[0].contextConditional}}Enabled(&element->document()))
+{%- if list[0].runtimeEnabled %}
+    if (!RuntimeEnabledFeatures::{{list[0].runtimeEnabled}}Enabled())
         return createV8{{namespace}}FallbackWrapper(to{{fallback_js_interface}}(element), creationContext, isolate);
 {%- endif %}
     return wrap(static_cast<{{js_interface}}*>(element), creationContext, isolate);
 }
 {%- endfor %}
 
 v8::Handle<v8::Object> createV8{{namespace}}Wrapper({{namespace}}Element* element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     typedef HashMap<StringImpl*, Create{{namespace}}ElementWrapperFunction> FunctionMap;
     DEFINE_STATIC_LOCAL(FunctionMap, map, ());
     if (map.isEmpty()) {
 {%- for tag in tags|sort %}
         map.set({{tag|symbol}}Tag.localName().impl(), create{{tag.js_interface}}Wrapper);
 {%- endfor %}
-    } // taco
+    }
 
     Create{{namespace}}ElementWrapperFunction createWrapperFunction = map.get(element->localName().impl());
     if (createWrapperFunction == create{{namespace}}ElementWrapper)
         createWrapperFunction = createV8{{namespace}}DirectWrapper;
     if (element->isCustomElement())
         return CustomElementWrapper<{{namespace}}Element, V8{{namespace}}Element>::wrap(element, creationContext, isolate, createWrapperFunction);
 
     if (createWrapperFunction)
         return createWrapperFunction(element, creationContext, isolate);
 {%- if fallback_js_interface == namespace + "Element" %}
@@ skipping 15 matching lines @@
 {%- endfor %}
     }
 
     if (const WrapperTypeInfo* result = map.get(name.impl()))
         return result;
 
     return WrapperTypeTraits<{{fallback_js_interface}}>::wrapperTypeInfo();
 }
 
 }