src/cobalt/bindings/javascriptcore/templates/interface.cc.template

{#
 # Copyright 2015 Google Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #}
{% extends "interface-base.cc.template" %}
{% block includes %}
#include "third_party/WebKit/Source/JavaScriptCore/config.h"

{{ super() }}
#include "cobalt/script/javascriptcore/constructor_base.h"
#include "cobalt/script/javascriptcore/conversion_helpers.h"
#include "cobalt/script/javascriptcore/prototype_base.h"
#include "cobalt/script/javascriptcore/jsc_callback_function.h"
#include "cobalt/script/javascriptcore/jsc_callback_interface_holder.h"
#include "cobalt/script/javascriptcore/jsc_exception_state.h"
#include "cobalt/script/javascriptcore/jsc_global_environment.h"
#include "cobalt/script/javascriptcore/jsc_global_object.h"
#include "cobalt/script/javascriptcore/jsc_object_handle.h"
#include "cobalt/script/javascriptcore/jsc_object_handle_holder.h"
{% if named_property_getter %}
#include "cobalt/script/javascriptcore/jsc_property_enumerator.h"
{% endif %}
#include "cobalt/script/javascriptcore/type_traits.h"
#include "cobalt/script/javascriptcore/util/binding_helpers.h"
#include "cobalt/script/javascriptcore/util/exception_helpers.h"
#include "third_party/WebKit/Source/JavaScriptCore/interpreter/Interpreter.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/Error.h"
{% if is_exception_interface %}
#include "third_party/WebKit/Source/JavaScriptCore/runtime/ErrorPrototype.h"
{% endif %}
#include "third_party/WebKit/Source/JavaScriptCore/runtime/FunctionPrototype.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/Identifier.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/JSFunction.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/JSGlobalObject.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/ObjectPrototype.h"
{% endblock includes %}
{% block using_directives %}
{{ super() }}
using cobalt::script::javascriptcore::kConversionFlagNullable;
using cobalt::script::javascriptcore::kConversionFlagRestricted;
using cobalt::script::javascriptcore::kConversionFlagTreatNullAsEmptyString;
using cobalt::script::javascriptcore::kConversionFlagTreatUndefinedAsEmptyString;
using cobalt::script::javascriptcore::kNoConversionFlags;
using cobalt::script::javascriptcore::ConstructorBase;
using cobalt::script::javascriptcore::GetWrappableOrSetException;
using cobalt::script::javascriptcore::FromJSValue;
using cobalt::script::javascriptcore::FromWTFString;
using cobalt::script::javascriptcore::JSCCallbackFunction;
using cobalt::script::javascriptcore::JSCCallbackFunctionHolder;
using cobalt::script::javascriptcore::JSCCallbackInterfaceHolder;
using cobalt::script::javascriptcore::JSCEngine;
using cobalt::script::javascriptcore::JSCExceptionState;
using cobalt::script::javascriptcore::JSCGlobalEnvironment;
using cobalt::script::javascriptcore::JSCGlobalObject;
using cobalt::script::javascriptcore::JSCObjectHandle;
using cobalt::script::javascriptcore::JSCObjectHandleHolder;
{% if named_property_getter %}
using cobalt::script::javascriptcore::JSCPropertyEnumerator;
{% endif %}
using cobalt::script::javascriptcore::JSObjectToWrappable;
using cobalt::script::javascriptcore::PrototypeBase;
using cobalt::script::javascriptcore::ScriptObjectRegistry;
using cobalt::script::javascriptcore::ThreadLocalHashTable;
using cobalt::script::javascriptcore::ToJSValue;
using cobalt::script::javascriptcore::ToWTFString;
using cobalt::script::javascriptcore::TypeTraits;
using cobalt::script::javascriptcore::WrapperBase;
using cobalt::script::javascriptcore::util::HasPropertyOnPrototype;
using cobalt::script::javascriptcore::util::GetStackTrace;
{% endblock using_directives %}
{% block enumeration_declarations %}
{% if enumerations|length %}
// Declare and define these in the same namespace that the other overloads
// were brought into with the using declaration.
{% for enumeration in enumerations %}
JSC::JSValue ToJSValue(JSCGlobalObject*, {{impl_class}}::{{enumeration.name}} in_enum);
void FromJSValue(JSC::ExecState* exec_state, JSC::JSValue jsvalue,
    int conversion_flags, JSCExceptionState* exception_state,
    {{impl_class}}::{{enumeration.name}}* out_enum);
{% endfor %}
{% endif %}
{% endblock enumeration_declarations %}

{% from 'macros.cc.template' import add_extra_arguments %}
{% from 'macros.cc.template' import call_function %}
{% from 'macros.cc.template' import constructor_implementation with context %}
{% from 'macros.cc.template' import function_implementation with context %}
{% from 'macros.cc.template' import overload_resolution_implementation with context %}
{% from 'macros.cc.template' import set_attribute_implementation with context %}
{% from 'interface-object.template' import create_interface_object with context %}

{% block implementation %}
namespace {
{% for constant in constants %}
JSC::JSValue getJS{{constant.idl_name}}(
    JSC::ExecState* exec_state,
    JSC::JSValue slot_base,
    JSC::PropertyName property_name);
{% endfor %}
{% for attribute in attributes + static_attributes %}
{% if attribute.conditional %}
#if defined({{attribute.conditional}})
{% endif %}
JSC::JSValue getJS{{attribute.idl_name}}(
    JSC::ExecState* exec_state,
    JSC::JSValue slot_base,
    JSC::PropertyName property_name);
{% if attribute.has_setter %}
void setJS{{attribute.idl_name}}(
    JSC::ExecState* exec,
    JSC::JSObject* this_object,
    JSC::JSValue value);
{% endif %}
{% if attribute.conditional %}
#endif  // defined({{attribute.conditional}})
{% endif %}
{% endfor %}
{% if constructor %}
JSC::EncodedJSValue constructorJS{{impl_class}}(JSC::ExecState*);
{% for overload in constructor.overloads if constructor.overloads|length > 1 %}
JSC::EncodedJSValue constructorJS{{impl_class}}{{overload.overload_index}}(JSC::ExecState*);
{% endfor %}
{% endif %}
{% for operation in operations + static_operations %}
{% if operation.conditional %}
#if defined({{operation.conditional}})
{% endif %}
{% set boundFunctionPrefix = "staticFunctionJS" if operation.is_static else "functionJS" %}
JSC::EncodedJSValue {{boundFunctionPrefix}}{{operation.idl_name}}(JSC::ExecState*);
{% for overload in operation.overloads if operation.overloads|length > 1 %}
JSC::EncodedJSValue {{boundFunctionPrefix}}{{overload.idl_name}}{{overload.overload_index}}(JSC::ExecState*);
{% endfor %}
{% if operation.conditional %}
#endif  // defined({{operation.conditional}})
{% endif %}
{% endfor %}
{% if indexed_property_getter %}
JSC::JSValue IndexedPropertyGetter(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, uint32_t index);
{% endif %}
{% if indexed_property_setter %}
void IndexedPropertySetter(JSC::JSCell* cell,
    JSC::ExecState* exec_state, uint32_t index, JSC::JSValue value);
{% endif %}
{% if stringifier %}
JSC::EncodedJSValue StringifierJS(JSC::ExecState*);
{% endif %}

// These are declared unconditionally, but only defined if needed by the
// interface.
JSC::JSValue NamedPropertyGetter(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, JSC::PropertyName property_name);
void NamedPropertySetter(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name, JSC::JSValue jsc_value);
bool NamedPropertyDeleter(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name);
bool QueryNamedProperty(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name);
JSC::JSValue OnGetMissingProperty(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, JSC::PropertyName property_name);
bool OnSetMissingProperty(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name, JSC::JSValue value);

const bool s_has_named_getter = {{'true' if named_property_getter else 'false'}};
const bool s_has_named_setter = {{'true' if named_property_setter else 'false'}};
#if !defined(COBALT_BUILD_TYPE_GOLD)
const bool s_use_debug_missing_property_handler = {{'true' if not parent_interface else 'false'}};
#else
const bool s_use_debug_missing_property_handler = false;
#endif
{% if get_opaque_root %}
scoped_refptr<Wrappable> GetOpaqueRootFromWrappable(
    const scoped_refptr<Wrappable>& wrappable) {
  {{impl_class}}* impl =
      base::polymorphic_downcast<{{impl_class}}*>(wrappable.get());
  Wrappable* opaque_root = impl->{{get_opaque_root}}();
  return make_scoped_refptr<Wrappable>(opaque_root);
}
{% endif %}
}  // namespace

{% if has_interface_object %}
{{create_interface_object("InterfaceObject", impl_class)}}
{% endif %}
{% if named_constructor %}
{{create_interface_object("NamedInterfaceObject", named_constructor)}}
{% endif %}
{% include "prototype-object.template" %}

const JSC::HashTableValue {{binding_class}}::property_table_values[] = {
{% for attribute in attributes %}
{% if attribute.conditional %}
#if defined({{attribute.conditional}})
{% endif %}
    { "{{attribute.idl_name}}",
        JSC::DontDelete {{'| JSC::ReadOnly' if not attribute.has_setter}},
        reinterpret_cast<intptr_t>(getJS{{attribute.idl_name}}),
        {% if attribute.has_setter %}
        reinterpret_cast<intptr_t>(setJS{{attribute.idl_name}}),
        {% else %}
        0,
        {% endif %}
        JSC::NoIntrinsic
    },
{% if attribute.conditional %}
#endif   // defined({{attribute.conditional}})
{% endif %}
{% endfor %}
{% if is_global_interface %}
{% for operation in operations %}
{% if operation.conditional %}
#if defined({{operation.conditional}})
{% endif %}
    { "{{operation.idl_name}}",
        JSC::DontDelete | JSC::Function,
        reinterpret_cast<intptr_t>(functionJS{{operation.idl_name}}),
        static_cast<intptr_t>({{operation.length}}),
        JSC::NoIntrinsic
    },
{% if operation.conditional %}
#endif  // defined({{operation.conditional}})
{% endif %}
{% endfor %}
{% endif %}
    { 0, 0, 0, 0, static_cast<JSC::Intrinsic>(0) }
};  // {{binding_class}}::property_table_values

// static
const JSC::HashTable {{binding_class}}::property_table_prototype = {
{# This doesn't take into account disabled properties, but this is okay. This
   value must be at least as large as the number of properties. #}
{% set num_properties = attributes|length %}
{% if is_global_interface %}
{% set num_properties = num_properties + operations|length %}
{% endif %}
    {{ calculate_jsc_lookup_size(num_properties) }},  // compactSize
    {{ calculate_jsc_lookup_size_mask(num_properties) }},  // compactSizeMask
    property_table_values,
    NULL  // table allocated at runtime
};  // {{binding_class}}::property_table_prototype

// static
const JSC::HashTable* {{binding_class}}::GetPropertyTable(
    JSC::ExecState* exec_state) {
  return ThreadLocalHashTable::GetInstance()->GetHashTable(
      {{binding_class}}::s_classinfo(), property_table_prototype);
}

#ifdef __LB_SHELL__FORCE_LOGGING__
base::LazyInstance<{{binding_class}}::NonTrivialStaticFields>
    {{binding_class}}::non_trivial_static_fields = LAZY_INSTANCE_INITIALIZER;
#endif  // __LB_SHELL__FORCE_LOGGING__

const JSC::ClassInfo {{binding_class}}::s_info = {
    "{{interface_name}}",  // className
    BaseClass::s_classinfo(),  // parentClass
    NULL,  // static hash-table of properties (not used)
    GetPropertyTable,  // function pointer to get hash-table of properties
    CREATE_METHOD_TABLE({{binding_class}})
};  // {{binding_class}}::s_info

// static
JSC::JSObject* {{binding_class}}::GetPrototype(
    JSC::JSGlobalObject* global_object) {
  return Prototype::GetInstance(global_object);
}

{% if has_interface_object %}
// static
JSC::JSObject* {{binding_class}}::GetConstructor(
    JSC::ExecState* exec_state) {
  return InterfaceObject::GetInstance(exec_state);
}

// static
JSC::JSValue {{binding_class}}::Prototype::GetConstructor(
      JSC::ExecState* exec_state,
      JSC::JSValue slot_base,
      JSC::PropertyName property_name) {
  return JSC::JSValue(InterfaceObject::GetInstance(exec_state));
}
{% endif %}
{% if named_constructor %}
JSC::JSObject* {{binding_class}}::GetNamedConstructor(
    JSC::ExecState* exec_state) {
  return NamedInterfaceObject::GetInstance(exec_state);
}
{% endif %}
{% if is_global_interface %}

// static
script::javascriptcore::JSCGlobalObject* {{binding_class}}::Create(
    const scoped_refptr<{{impl_class}}>& global_interface,
    script::EnvironmentSettings* environment_settings,
    JSC::JSGlobalData* global_data,
    ScriptObjectRegistry* script_object_registry) {
  scoped_ptr<script::javascriptcore::WrapperFactory> wrapper_factory =
      make_scoped_ptr(new script::javascriptcore::WrapperFactory());
{% for interface in all_interfaces %}
{% if interface.conditional %}
#if defined({{interface.conditional}})
{% endif %}
  {# Don't register a create method for the global interface, since we do not
     create a wrapper for it directly. #}
  {% if interface.name != impl_class %}
  wrapper_factory->RegisterWrappableType(
      {{interface.name}}::{{interface.name}}WrappableType(),
      JSC{{interface.name}}::s_classinfo(),
      JSC{{interface.name}}::GetCreateWrapperFunction());
  {% endif %}
{% if interface.conditional %}
#endif  // defined({{interface.conditional}})
{% endif %}
{% endfor %}

  JSC::JSLockHolder lock(global_data);
  JSC::Structure* structure = JSC::Structure::create(
      *global_data,
      NULL,           // JSC::JSGlobalObject*
      JSC::jsNull(),  // prototype
      JSC::TypeInfo(JSC::GlobalObjectType, StructureFlags),
      &s_info);
  {{binding_class}}* global_wrapper =
      new (NotNull, JSC::allocateCell<{{binding_class}}>(global_data->heap))
      {{binding_class}}(
          global_data,
          structure,
          script_object_registry,
          wrapper_factory.Pass(),
          environment_settings,
          global_interface);
  global_wrapper->finishCreation(*global_data);
  global_data->heap.addFinalizer(global_wrapper, {{binding_class}}::destroy);
  global_wrapper->setPrototype(
      global_wrapper->globalData(),
      {{binding_class}}::GetPrototype(global_wrapper));

  return global_wrapper;
}
{% else %}

// static
JSC::JSObject* {{binding_class}}::Create(
    JSCGlobalObject* global_object,
    const scoped_refptr<Wrappable>& wrappable) {
  if (!(wrappable->GetWrappableType() == {{impl_class}}::{{impl_class}}WrappableType())) {
    NOTREACHED() << "Type of wrappable does not match {{impl_class}}::{{impl_class}}WrappableType()";
    return NULL;
  }
  {{impl_class}}* impl_ptr =
      base::polymorphic_downcast<{{impl_class}}*>(wrappable.get());

  JSC::JSGlobalData& global_data = global_object->globalData();

  // Get or Create the prototype object for this interface.
  JSC::JSObject* prototype = Prototype::GetInstance(global_object);
  DCHECK(prototype);

  JSC::JSLockHolder lock(global_data);
  // Create a JSC::Structure object for this instance.
{% if is_exception_interface %}
  JSC::TypeInfo type_info(JSC::ErrorInstanceType, StructureFlags);
{% else %}
  JSC::TypeInfo type_info(JSC::ObjectType, StructureFlags);
{% endif %}
  JSC::Structure* structure = JSC::Structure::create(
      global_data,
      global_object,
      JSC::JSValue(prototype),
      type_info,
      &s_info);

  // Instantiate a new garbage-collected wrapper object.
  {{binding_class}}* wrapper =
      new (NotNull, JSC::allocateCell<{{binding_class}}>(global_data.heap))
      {{binding_class}}(
          &global_data,
          structure,
          global_object->script_object_registry(),
          make_scoped_refptr(impl_ptr));
  wrapper->finishCreation(global_data);
{% if is_exception_interface %}
  global_data.heap.addFinalizer(wrapper, destroy);
{% endif %}
  return wrapper;
}
{% endif %}
{{binding_class}}::{{binding_class}}(
    JSC::JSGlobalData* global_data,
    JSC::Structure* structure,
    ScriptObjectRegistry* script_object_registry,
{% if is_global_interface %}
    scoped_ptr<script::javascriptcore::WrapperFactory> wrapper_factory,
    script::EnvironmentSettings* environment_settings,
{% endif %}
    const scoped_refptr<{{impl_class}}>& impl)
    : BaseClass(global_data, structure, script_object_registry, impl{% if is_global_interface %},
      wrapper_factory.Pass(), environment_settings{% endif %}) {
{% if get_opaque_root %}
  set_get_opaque_root_function(base::Bind(&GetOpaqueRootFromWrappable));
{% endif %}
}

void {{binding_class}}::finishCreation(JSC::JSGlobalData& global_data) {
{% if is_exception_interface %}
  WTF::String error_message = ToWTFString(wrappable()->message());
  BaseClass::finishCreation(global_data, error_message);
{% else %}
  BaseClass::finishCreation(global_data);
{% endif %}
  DCHECK(inherits(&s_info));
}

{{binding_class}}::~{{binding_class}}() {
  // Empty destructor
}
{% if add_opaque_roots %}

void {{binding_class}}::visitChildren(JSC::JSCell* cell, JSC::SlotVisitor& visitor) {
  WrapperBase<JSC::JSDestructibleObject, Wrappable>::visitChildren(
      cell, visitor);

  JSCGlobalObject* global_object = JSC::jsCast<JSCGlobalObject*>(
      JSC::jsCast<JSObject*>(cell)->globalObject());

  {{impl_class}}* impl = base::polymorphic_downcast<{{impl_class}}*>(
      JSC::jsCast<WrapperBase*>(cell)->wrappable().get());

{% for opaque_root in add_opaque_roots %}
  Wrappable* opaque_root{{loop.index0}} = impl->{{opaque_root}}();
  if (opaque_root{{loop.index0}}) {
    visitor.addOpaqueRoot(opaque_root{{loop.index0}});
  }
{% endfor %}
}
{% endif %}

// Look up property slot for querying property values.
bool {{binding_class}}::getOwnPropertySlot(JSC::JSCell* cell,
    JSC::ExecState* exec, JSC::PropertyName property_name,
    JSC::PropertySlot& slot) {
  {{binding_class}}* this_object = JSC::jsCast<{{binding_class}}*>(cell);
  ASSERT_GC_OBJECT_INHERITS(this_object, &s_info);
{% if is_global_interface %}
  // Global interface may have both operations and properties as own properties
  // so we cannot use getStaticValueSlot.
  bool found_property_slot = JSC::getStaticPropertySlot<{{binding_class}}, BaseClass>(
      exec, GetPropertyTable(exec), this_object, property_name, slot);
{% else %}
  bool found_property_slot = JSC::getStaticValueSlot<{{binding_class}}, BaseClass>(
      exec, GetPropertyTable(exec), this_object, property_name, slot);
{% endif %}
  if (s_has_named_getter || s_use_debug_missing_property_handler) {
    bool found_property_on_prototype_chain = false;
    if (!found_property_slot && cell->isObject()) {
      JSC::JSValue prototype_value = JSC::asObject(cell)->prototype();
      if (prototype_value.isObject()) {
        JSC::JSObject* prototype = JSC::asObject(prototype_value);
        found_property_on_prototype_chain =
            prototype->hasProperty(exec, property_name);
      }
    }
    if (s_has_named_getter) {
      if (!found_property_slot && !found_property_on_prototype_chain) {
        if (QueryNamedProperty(this_object, exec, property_name)) {
          slot.setCustom(cell, &NamedPropertyGetter);
          found_property_slot = true;
        }
      }
    }
    if (s_use_debug_missing_property_handler) {
      // The property was not found as an own-property, nor was it found on the
      // prototype chain, so set the missing property handler to be called
      // when getting this property value.
      if (!found_property_slot && !found_property_on_prototype_chain) {
        slot.setCustom(cell, &OnGetMissingProperty);
        found_property_slot = true;
      }
    }
  }
  return found_property_slot;
}
{% if indexed_property_getter or named_property_getter %}

// static
bool {{binding_class}}::getOwnPropertySlotByIndex(JSC::JSCell* cell,
    JSC::ExecState* exec_state, uint32_t index, JSC::PropertySlot& slot) {
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (!impl) {
    return false;
  }
{% if indexed_property_getter %}
  if (index < impl->length()) {
    slot.setCustomIndex(cell, index, IndexedPropertyGetter);
    return true;
  }
{% endif %}
  if (s_has_named_getter) {
    {{binding_class}}* this_object = JSC::jsCast<{{binding_class}}*>(cell);
    JSC::PropertyName property_name = JSC::Identifier::from(exec_state, index);
    bool has_property = HasOwnPropertyOrPrototypeProperty(
        cell, exec_state, property_name);
    if (!has_property) {
      if (QueryNamedProperty(this_object, exec_state, property_name)) {
        slot.setCustom(cell, &NamedPropertyGetter);
        return true;
      }
    }
  }
  return Base::getOwnPropertySlotByIndex(cell, exec_state, index, slot);
}

void {{binding_class}}::getOwnPropertyNames(JSC::JSObject* object,
    JSC::ExecState* exec_state, JSC::PropertyNameArray& property_names,
    JSC::EnumerationMode mode) {
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, object);
  if (impl) {
{% if indexed_property_getter %}
    for (uint32 i = 0; i < impl->length(); ++i) {
      property_names.add(JSC::Identifier::from(exec_state, i));
    }
{% endif %}
{% if named_property_getter %}
    JSCPropertyEnumerator enumerator(exec_state, &property_names);
    impl->EnumerateNamedProperties(&enumerator);
{% endif %}
    Base::getOwnPropertyNames(object, exec_state, property_names, mode);
  }
}
{% endif %}

// Look up property slot and put the |value|.
void {{binding_class}}::put(JSC::JSCell* cell, JSC::ExecState* exec,
    JSC::PropertyName property_name, JSC::JSValue value,
    JSC::PutPropertySlot& slot) {
  {{binding_class}}* this_object = JSC::jsCast<{{binding_class}}*>(cell);
  ASSERT_GC_OBJECT_INHERITS(this_object, &s_info);
  bool property_handled = false;
  if (s_has_named_setter || s_use_debug_missing_property_handler) {
    // Need to look up the property manually.
    bool has_property = HasOwnPropertyOrPrototypeProperty(
        cell, exec, property_name);

    if (s_has_named_setter) {
      // We didn't find the property on the object or prototype chain, so
      // set or create a new named property.
      if (!has_property) {
        std::string property_name_utf8 = FromWTFString(property_name.publicName());
        NamedPropertySetter(cell, exec, property_name, value);
        property_handled = true;
      }
    }
    if (s_use_debug_missing_property_handler) {
      if (!has_property && !property_handled) {
        property_handled = OnSetMissingProperty(cell, exec, property_name, value);
      }
    }
{% if not is_global_interface and not parent_interface %}
#ifdef __LB_SHELL__FORCE_LOGGING__
    std::string property_name_utf8 = FromWTFString(property_name.publicName());

    base::AutoLock lock(non_trivial_static_fields.Get().lock_);
    base::hash_set<std::string>& properties_warned_about =
        non_trivial_static_fields.Get().properties_warned_about;

    if (properties_warned_about.find(property_name_utf8) ==
        properties_warned_about.end()) {
      properties_warned_about.insert(property_name_utf8);
      WTF::String class_name = cell->className();
      DLOG_IF(WARNING, !has_property) << "Did not find property named " <<
              property_name_utf8 << " to set on wrapper for "
              << FromWTFString(class_name)
              << std::endl << StackTraceToString(GetStackTrace(exec, 32))
              << std::endl;
    }
#endif  // __LB_SHELL__FORCE_LOGGING__
{% endif %}
  }

  if (!property_handled) {
    JSC::lookupPut<{{binding_class}}, BaseClass>(
        exec, property_name, value, GetPropertyTable(exec), this_object, slot);
  }
}
{% if indexed_property_setter or named_property_setter %}

// static
void {{binding_class}}::putByIndex(JSC::JSCell* cell,
    JSC::ExecState* exec_state, uint32_t index, JSC::JSValue value,
    bool should_throw) {
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (impl) {
    bool property_handled = false;
{% if indexed_property_setter %}
    if (index < impl->length()) {
      IndexedPropertySetter(cell, exec_state, index, value);
      property_handled = true;
    }
{% endif %}
    if (s_has_named_setter) {
      if (!property_handled) {
        JSC::PropertyName property_name = JSC::Identifier::from(exec_state, index);
        bool has_property = HasOwnPropertyOrPrototypeProperty(
            cell, exec_state, property_name);
        if (!has_property) {
          NamedPropertySetter(cell, exec_state, property_name, value);
          property_handled = true;
        }
      }
    }
    if (!property_handled) {
      Base::putByIndex(cell, exec_state, index, value, should_throw);
    }
  }
}

{% endif %}
{% if supports_named_properties %}

bool {{binding_class}}::deleteProperty(JSC::JSCell* cell,
                                       JSC::ExecState* exec_state,
                                       JSC::PropertyName property_name) {
  TRACE_EVENT1("{{binding_class}}", "deleteProperty", "property",
               TRACE_STR_COPY(WTF::String(property_name.publicName()).utf8().data()));
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (impl) {
    bool has_property = HasOwnPropertyOrPrototypeProperty(
        cell, exec_state, property_name);
    if (!has_property &&
        QueryNamedProperty(cell, exec_state, property_name)) {
      return NamedPropertyDeleter(cell, exec_state, property_name);
    }
    return Base::deleteProperty(cell, exec_state, property_name);
  }
  return false;
}
{% endif %}
{% if supports_named_properties or supports_indexed_properties %}

bool {{binding_class}}::deletePropertyByIndex(JSC::JSCell* cell,
                                              JSC::ExecState* exec_state,
                                              uint32_t index) {
  TRACE_EVENT0("{{binding_class}}", "deletePropertyByIndex");
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (impl) {
{% if supports_indexed_properties %}
    // https://heycam.github.io/webidl/#delete
    // Return true if index is not a supported property index.
    return index >= impl->length();
{% elif supports_named_properties %}
    JSC::PropertyName property_name = JSC::Identifier::from(exec_state, index);
    bool has_property = HasOwnPropertyOrPrototypeProperty(
        cell, exec_state, property_name);
    if (!has_property &&
        QueryNamedProperty(cell, exec_state, property_name)) {
      return NamedPropertyDeleter(cell, exec_state, property_name);
    }
    return Base::deletePropertyByIndex(cell, exec_state, index);
{% endif %}
  }
  return false;
}
{% endif %}

bool {{binding_class}}::HasOwnPropertyOrPrototypeProperty(
    JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name) {
  {{binding_class}}* this_object = JSC::jsCast<{{binding_class}}*>(cell);
  JSC::PropertySlot lookup_slot;
  bool has_property = JSC::getStaticPropertySlot<{{binding_class}}, BaseClass>(
      exec_state, GetPropertyTable(exec_state), this_object, property_name,
      lookup_slot);
  return has_property || HasPropertyOnPrototype(exec_state, cell, property_name);
}

namespace {
{% for constant in constants %}

JSC::JSValue getJS{{constant.idl_name}}(
    JSC::ExecState* exec_state, JSC::JSValue, JSC::PropertyName) {
  TRACE_EVENT0("{{binding_class}}", "get {{constant.idl_name}}");
{% if constant.can_use_compile_assert %}
  COMPILE_ASSERT({{impl_class}}::{{constant.name}} == {{constant.value}},
                 ValueFor{{impl_class}}_{{constant.name}}DoesNotMatchIDL);
{% else %}
  DCHECK_EQ({{constant.value}}, {{impl_class}}::{{constant.name}}) <<
      "The value for {{impl_class}}::{{constant.name}} does not match "
      "the value in the interface definition.";
{% endif %}
  // JSCGlobalObject* is only needed for non-primitive types.
  return ToJSValue(NULL, {{constant.value}});
}
{% endfor %}
{% for attribute in attributes + static_attributes %}

{% if attribute.conditional %}
#if defined({{attribute.conditional}})
{% endif %}
JSC::JSValue getJS{{attribute.idl_name}}(
    JSC::ExecState* exec_state,
    JSC::JSValue slot_base,
    JSC::PropertyName property_name) {
  TRACE_EVENT0("{{binding_class}}", "get {{attribute.idl_name}}");
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
{% if not attribute.is_static %}
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, slot_base);
  if (!impl) {
    return exec_state->exception();
  }
{% endif %}
{% if attribute.raises_exception %}
  JSCExceptionState exception_state(global_object);
{% endif %}

{% if attribute.is_named_constructor_attribute %}
  JSC::JSObject* constructor_object =
      JSC{{attribute.interface_name}}::GetNamedConstructor(
          global_object->globalExec());
  DCHECK(constructor_object)
      << "NULL constructor returned for {{attribute.interface_name}}.";
  return JSC::JSValue(constructor_object);
{% elif attribute.is_constructor_attribute %}
  JSC::JSObject* constructor_object =
      JSC{{attribute.interface_name}}::GetConstructor(
          global_object->globalExec());
  DCHECK(constructor_object)
      << "NULL constructor returned for {{attribute.interface_name}}.";
  return JSC::JSValue(constructor_object);
{% else %}
{% call(arguments_list) add_extra_arguments('global_object', [], attribute) %}
  JSC::JSValue result = ToJSValue(
      global_object,
      {{ call_function("impl", impl_class, attribute.getter_function_name, arguments_list, attribute.is_static) -}});
{% if attribute.raises_exception %}
  if (exception_state.is_exception_set()) {
    return JSC::throwError(exec_state, exception_state.exception_object());
  }
{% endif %}
  return result;
{% endcall %}
{% endif %}
}
{% if attribute.has_setter %}

void setJS{{attribute.idl_name}}(
    JSC::ExecState* exec_state,
    JSC::JSObject* this_object,
    JSC::JSValue value) {
  TRACE_EVENT0("{{binding_class}}", "set {{attribute.idl_name}}");
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSCExceptionState exception_state(global_object);
{% if not attribute.is_static %}
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, this_object);
  if (!impl) {
    return;
  }
{% endif %}
{{ set_attribute_implementation(attribute, impl_class, "impl") }}
}
{% endif %}
{% if attribute.conditional %}
#endif  // defined({{attribute.conditional}})
{% endif %}
{% endfor %}
{% if constructor %}

JSC::EncodedJSValue constructorJS{{impl_class}}(JSC::ExecState* exec_state) {
{% if constructor.overloads|length == 1 %}
{{constructor_implementation(constructor.overloads[0])}}
{% else %}
{{overload_resolution_implementation(constructor, 'constructorJS' + impl_class)}}
{% endif %}
}
{% for overload in constructor.overloads if constructor.overloads|length > 1 %}

JSC::EncodedJSValue constructorJS{{impl_class}}{{overload.overload_index}}(JSC::ExecState* exec_state) {
{{constructor_implementation(overload)}}
}
{% endfor %}
{% endif %}
{% for operation in operations + static_operations %}
{% if operation.conditional %}
#if defined({{operation.conditional}})
{% endif %}

{% set boundFunctionPrefix = "staticFunctionJS" if operation.is_static else "functionJS" %}
JSC::EncodedJSValue {{boundFunctionPrefix}}{{operation.idl_name}}(
    JSC::ExecState* exec_state) {
  TRACE_EVENT0("{{binding_class}}", "call {{operation.idl_name}}");
{% if operation.overloads|length == 1 %}
{{function_implementation(operation.overloads[0])}}
{% else %}
{{overload_resolution_implementation(operation, boundFunctionPrefix + operation.idl_name)}}
{% endif %}
}
{% for overload in operation.overloads if operation.overloads|length > 1 %}

JSC::EncodedJSValue {{boundFunctionPrefix}}{{operation.idl_name}}{{overload.overload_index}}(
    JSC::ExecState* exec_state) {
{{function_implementation(overload)}}
}
{% endfor %}
{% if operation.conditional %}
#endif  // defined({{operation.conditional}})
{% endif %}
{% endfor %}
{% if indexed_property_getter %}

JSC::JSValue IndexedPropertyGetter(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, uint32_t index) {
  TRACE_EVENT0("{{binding_class}}", "IndexedPropertyGetter");
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, slot_base);
  if (!impl) {
    return exec_state->exception();
  }
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSCExceptionState exception_state(global_object);
{% call(arguments_list)
    add_extra_arguments('global_object', ['index'], indexed_property_getter) %}
  JSC::JSValue result = ToJSValue(
      global_object,
      {{ call_function("impl", impl_class, indexed_property_getter.name,
                       arguments_list, False) -}});
{% if indexed_property_getter.raises_exception %}
  if (exception_state.is_exception_set()) {
    return JSC::throwError(exec_state, exception_state.exception_object());
  }
{% endif %}
  return result;
{% endcall %}
}
{% endif %}
{% if indexed_property_setter %}

void IndexedPropertySetter(JSC::JSCell* cell,
      JSC::ExecState* exec_state, uint32_t index, JSC::JSValue jsc_value) {
  TRACE_EVENT0("{{binding_class}}", "IndexedPropertySetter");
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (!impl) {
    return;
  }

  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSCExceptionState exception_state(global_object);
  {{indexed_property_setter.type}} value;
  FromJSValue(exec_state, jsc_value,
      {{indexed_property_setter.conversion_flags}},
      &exception_state, &value);
  if (exception_state.is_exception_set()) {
    JSC::throwError(exec_state, exception_state.exception_object());
    return;
  }
{% call(arguments_list) add_extra_arguments(
    'global_object', ['index', 'value'], indexed_property_setter) %}
  {{ call_function("impl", impl_class, indexed_property_setter.name,
                   arguments_list, False) -}};
{% if indexed_property_setter.raises_exception %}
  if (exception_state.is_exception_set()) {
    JSC::throwError(exec_state, exception_state.exception_object());
  }
{% endif %}
{% endcall %}
}
{% endif %}
{% if named_property_getter %}

JSC::JSValue NamedPropertyGetter(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, JSC::PropertyName property_name) {
  TRACE_EVENT0("{{binding_class}}", "NamedPropertyGetter");
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, slot_base);
  if (!impl) {
    return exec_state->exception();
  }
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSCExceptionState exception_state(global_object);
  std::string property_name_utf8 = FromWTFString(property_name.publicName());
{% call(arguments_list) add_extra_arguments('global_object', ['property_name_utf8'], named_property_getter) %}
  JSC::JSValue result = ToJSValue(
      global_object,
      {{ call_function("impl", impl_class, named_property_getter.name, arguments_list, False) -}});
{% if named_property_getter.raises_exception %}
  if (exception_state.is_exception_set()) {
    return JSC::throwError(exec_state, exception_state.exception_object());
  }
{% endif %}
  return result;
{% endcall %}
}

bool QueryNamedProperty(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name) {
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (!impl) {
    return false;
  }
  std::string property_name_utf8 = FromWTFString(property_name.publicName());
  return impl->CanQueryNamedProperty(property_name_utf8);
}
{% else %}
JSC::JSValue NamedPropertyGetter(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, JSC::PropertyName property_name) {
  NOTREACHED();
  return JSC::jsUndefined();
}
bool QueryNamedProperty(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name) {
  NOTREACHED();
  return false;
}
{% endif %}
{% if named_property_setter %}

void NamedPropertySetter(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name, JSC::JSValue jsc_value) {
  TRACE_EVENT0("{{binding_class}}", "NamedPropertySetter");
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (!impl) {
    return;
  }

  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSCExceptionState exception_state(global_object);

  std::string property_name_utf8 = FromWTFString(property_name.publicName());
  {{named_property_setter.type}} value;
  FromJSValue(exec_state, jsc_value,
      {{named_property_setter.conversion_flags}},
      &exception_state, &value);
  if (exception_state.is_exception_set()) {
    JSC::throwError(exec_state, exception_state.exception_object());
    return;
  }
{% call(arguments_list) add_extra_arguments(
    'global_object', ['property_name_utf8', 'value'], named_property_setter) %}
  {{ call_function(
      "impl", impl_class, named_property_setter.name, arguments_list, False) -}};
{% if named_property_setter.raises_exception %}
  if (exception_state.is_exception_set()) {
    JSC::throwError(exec_state, exception_state.exception_object());
  }
{% endif %}
{% endcall %}
}
{% else %}
void NamedPropertySetter(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name, JSC::JSValue jsc_value) {
  NOTREACHED();
}
{% endif %}

bool NamedPropertyDeleter(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name) {
{% if named_property_deleter %}
    {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, cell);
  if (impl) {
    std::string property_name_utf8 = FromWTFString(property_name.publicName());
    impl->{{named_property_deleter.name}}(property_name_utf8);
    return true;
  }
{% endif %}
  return false;
}
{% if stringifier %}

JSC::EncodedJSValue StringifierJS(JSC::ExecState* exec_state) {
  JSC::JSObject* this_object =
      exec_state->hostThisValue().toThisObject(exec_state);
  {{impl_class}}* impl =
      GetWrappableOrSetException<{{impl_class}}>(exec_state, this_object);
  if (!impl) {
    return JSC::JSValue::encode(exec_state->exception());
  }
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());

  JSC::JSValue result = ToJSValue(global_object, impl->{{stringifier.name}}());
  return JSC::JSValue::encode(result);
}
{% endif %}

#if !defined(COBALT_BUILD_TYPE_GOLD)
JSC::JSValue OnGetMissingProperty(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, JSC::PropertyName property_name) {
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSC::JSValue callable = global_object->get(
      exec_state, JSC::Identifier(exec_state, "__onGetMissingProperty"));
  if (!callable.isUndefined()) {
    JSC::CallData call_data;
    JSC::CallType call_type = JSC::getCallData(callable, call_data);
    if (call_type != JSC::CallTypeNone) {
      // The function called __onGetMissingProperty exists, so call this and
      // return the result as the value for this property.
      JSC::MarkedArgumentBuffer args;
      args.append(slot_base);
      args.append(JSC::JSValue(
              JSC::JSString::create(
                  global_object->globalData(), property_name.publicName())));
      JSC::JSValue retval = JSC::call(
          exec_state, callable, call_type, call_data, global_object, args);
      return retval;
    }
  }
  return JSC::jsUndefined();
}

bool OnSetMissingProperty(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name, JSC::JSValue value) {
  JSCGlobalObject* global_object =
      JSC::jsCast<JSCGlobalObject*>(exec_state->lexicalGlobalObject());
  JSC::JSValue callable = global_object->get(
      exec_state, JSC::Identifier(exec_state, "__onSetMissingProperty"));
  if (!callable.isUndefined()) {
    JSC::CallData call_data;
    JSC::CallType call_type = JSC::getCallData(callable, call_data);
    if (call_type != JSC::CallTypeNone) {
      // The function called __onSetMissingProperty exists, so call this with
      // the value to be set. The missing property handler returns true if it
      // has handled the setting of this property.
      JSC::MarkedArgumentBuffer args;
      args.append(cell);
      args.append(JSC::JSValue(
              JSC::JSString::create(
                  global_object->globalData(), property_name.publicName())));
      args.append(value);
      JSC::JSValue retval = JSC::call(
          exec_state, callable, call_type, call_data, global_object, args);
      return retval.toBoolean(exec_state);
    }
  }
  return false;
}
#else
JSC::JSValue OnGetMissingProperty(JSC::ExecState* exec_state,
    JSC::JSValue slot_base, JSC::PropertyName property_name) {
  NOTREACHED();
  return JSC::jsUndefined();
}
bool OnSetMissingProperty(JSC::JSCell* cell, JSC::ExecState* exec_state,
    JSC::PropertyName property_name, JSC::JSValue value) {
  NOTREACHED();
  return false;
}
#endif
}  // namespace
{% endblock implementation %}

{% block create_global_object_impl %}
  JSCGlobalEnvironment* jsc_global_environment =
      base::polymorphic_downcast<JSCGlobalEnvironment*>(this);
  JSCEngine* jsc_engine = jsc_global_environment->engine();

  JSCGlobalObject* global_object = {{binding_class}}::Create(
      global_interface, environment_settings,
      jsc_engine->global_data(), jsc_engine->script_object_registry());
  jsc_global_environment->SetGlobalObject(global_object);
{% endblock create_global_object_impl %}

{% block enumeration_definitions %}
{% for enumeration in enumerations %}
JSC::JSValue ToJSValue(JSCGlobalObject* global_object, {{impl_class}}::{{enumeration.name}} in_enum) {
  JSC::JSGlobalData* global_data = &(global_object->globalData());
  switch (in_enum) {
{% for value, idl_value in enumeration.value_pairs %}
    case {{impl_class}}::{{value}}: return JSC::jsString(global_data, "{{idl_value}}");
{% endfor %}
    default:
      NOTREACHED();
      return JSC::jsUndefined();
  }
}
void FromJSValue(JSC::ExecState* exec_state, JSC::JSValue jsvalue,
                 int conversion_flags, JSCExceptionState* exception_state,
                 {{impl_class}}::{{enumeration.name}}* out_enum) {
  DCHECK_EQ(0, conversion_flags) << "Unexpected conversion flags.";
  // JSValue -> IDL enum algorithm described here:
  // http://heycam.github.io/webidl/#es-enumeration

  // 1. Let S be the result of calling ToString(V).
  JSC::JSString* js_string = jsvalue.toString(exec_state);
  if (exec_state->hadException()) {
    DLOG(WARNING) << "Exception converting value to string";
    return;
  }
  const WTF::String& wtf_string = js_string->tryGetValue();
  // 3. Return the enumeration value of type E that is equal to S.
{% for value, idl_value in enumeration.value_pairs %}
  {{-" else " if not loop.first}}if (wtf_string == "{{idl_value}}") {
    *out_enum = {{impl_class}}::{{value}};
  }{% endfor %} else {
    // 2. If S is not one of E's enumeration values, then throw a TypeError.
    JSC::throwTypeError(exec_state);
  }
}
{% endfor %}
{% endblock enumeration_definitions %}