text: // Copyright 2014 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
  
  #include "config.h"
  #include "V8DOMStringList.h"
  
  #include "bindings/core/v8/ExceptionState.h"
  #include "bindings/core/v8/V8DOMConfiguration.h"
  #include "bindings/core/v8/V8ObjectConstructor.h"
  #include "core/dom/ContextFeatures.h"
  #include "core/dom/Document.h"
  #include "core/frame/UseCounter.h"
  #include "platform/RuntimeEnabledFeatures.h"
  #include "platform/TraceEvent.h"
  #include "wtf/GetPtr.h"
  #include "wtf/RefPtr.h"
  
  namespace blink {
  
  // Suppress warning: global constructors, because struct WrapperTypeInfo is trivial
  // and does not depend on another global objects.
  #if defined(COMPONENT_BUILD) && defined(WIN32) && COMPILER(CLANG)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wglobal-constructors"
  #endif
  const WrapperTypeInfo V8DOMStringList::wrapperTypeInfo = { gin::kEmbedderBlink, V8DOMStringList::domTemplate, V8DOMStringList::refObject, V8DOMStringList::derefObject, V8DOMStringList::trace, 0, 0, V8DOMStringList::preparePrototypeObject, V8DOMStringList::installConditionallyEnabledProperties, "DOMStringList", 0, WrapperTypeInfo::WrapperTypeObjectPrototype, WrapperTypeInfo::ObjectClassId, WrapperTypeInfo::NotInheritFromEventTarget, WrapperTypeInfo::Independent, WrapperTypeInfo::WillBeGarbageCollectedObject };
  #if defined(COMPONENT_BUILD) && defined(WIN32) && COMPILER(CLANG)
  #pragma clang diagnostic pop
  #endif
  
  // This static member must be declared by DEFINE_WRAPPERTYPEINFO in DOMStringList.h.
  // For details, see the comment of DEFINE_WRAPPERTYPEINFO in
  // bindings/core/v8/ScriptWrappable.h.
  const WrapperTypeInfo& DOMStringList::s_wrapperTypeInfo = V8DOMStringList::wrapperTypeInfo;
  
  namespace DOMStringListV8Internal {
  
  static void lengthAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info)
  {
      v8::Local<v8::Object> holder = info.Holder();
      DOMStringList* impl = V8DOMStringList::toImpl(holder);
      v8SetReturnValueUnsigned(info, impl->length());
  }
  
  static void lengthAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
  {
      TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter");
      DOMStringListV8Internal::lengthAttributeGetter(info);
      TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
  }
  
  static void itemMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
  {
      ExceptionState exceptionState(ExceptionState::ExecutionContext, "item", "DOMStringList", info.Holder(), info.GetIsolate());
      if (UNLIKELY(info.Length() < 1)) {
          setMinimumArityTypeError(exceptionState, 1, info.Length());
          exceptionState.throwIfNeeded();
          return;
      }
      DOMStringList* impl = V8DOMStringList::toImpl(info.Holder());
      unsigned index;
      {
          index = toUInt32(info.GetIsolate(), info[0], NormalConversion, exceptionState);
          if (exceptionState.throwIfNeeded())
              return;
      }
      ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
      v8SetReturnValueStringOrNull(info, impl->item(executionContext, index), info.GetIsolate());
  }
  
  static void itemMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
  {
      TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
      DOMStringListV8Internal::itemMethod(info);
      TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
  }
  
  static void containsMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
  {
      if (UNLIKELY(info.Length() < 1)) {
          V8ThrowException::throwException(createMinimumArityTypeErrorForMethod(info.GetIsolate(), "contains", "DOMStringList", 1, info.Length()), info.GetIsolate());
          return;
      }
      DOMStringList* impl = V8DOMStringList::toImpl(info.Holder());
      V8StringResource<> string;
      {
          string = info[0];
          if (!string.prepare())
              return;
      }
      ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
      v8SetReturnValueBool(info, impl->contains(executionContext, string));
  }
  
  static void containsMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
  {
      TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
      UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::DOMStringListContains);
      DOMStringListV8Internal::containsMethod(info);
      TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
  }
  
  static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
  {
      DOMStringList* impl = V8DOMStringList::toImpl(info.Holder());
      String result = impl->anonymousIndexedGetter(index);
      if (result.isNull())
          return;
      v8SetReturnValueStringOrNull(info, result, info.GetIsolate());
  }
  
  static void indexedPropertyGetterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
  {
      TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMIndexedProperty");
      DOMStringListV8Internal::indexedPropertyGetter(index, info);
      TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
  }
  
  } // namespace DOMStringListV8Internal
  
  static const V8DOMConfiguration::AccessorConfiguration V8DOMStringListAccessors[] = {
      {"length", DOMStringListV8Internal::lengthAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::ExposedToAllScripts, V8DOMConfiguration::OnPrototype, V8DOMConfiguration::CheckHolder},
  };
  
  static const V8DOMConfiguration::MethodConfiguration V8DOMStringListMethods[] = {
      {"item", DOMStringListV8Internal::itemMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
      {"contains", DOMStringListV8Internal::containsMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
  };
  
  static void installV8DOMStringListTemplate(v8::Local<v8::FunctionTemplate> functionTemplate, v8::Isolate* isolate)
  {
      functionTemplate->ReadOnlyPrototype();
  
      v8::Local<v8::Signature> defaultSignature;
      defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "DOMStringList", v8::Local<v8::FunctionTemplate>(), V8DOMStringList::internalFieldCount,
          0, 0,
          V8DOMStringListAccessors, WTF_ARRAY_LENGTH(V8DOMStringListAccessors),
          V8DOMStringListMethods, WTF_ARRAY_LENGTH(V8DOMStringListMethods));
      v8::Local<v8::ObjectTemplate> instanceTemplate = functionTemplate->InstanceTemplate();
      ALLOW_UNUSED_LOCAL(instanceTemplate);
      v8::Local<v8::ObjectTemplate> prototypeTemplate = functionTemplate->PrototypeTemplate();
      ALLOW_UNUSED_LOCAL(prototypeTemplate);
      {
          v8::IndexedPropertyHandlerConfiguration config(DOMStringListV8Internal::indexedPropertyGetterCallback, 0, 0, 0, indexedPropertyEnumerator<DOMStringList>);
          functionTemplate->InstanceTemplate()->SetHandler(config);
      }
  
      // Custom toString template
      functionTemplate->Set(v8AtomicString(isolate, "toString"), V8PerIsolateData::from(isolate)->toStringTemplate());
  }
  
  v8::Local<v8::FunctionTemplate> V8DOMStringList::domTemplate(v8::Isolate* isolate)
  {
      return V8DOMConfiguration::domClassTemplate(isolate, const_cast<WrapperTypeInfo*>(&wrapperTypeInfo), installV8DOMStringListTemplate);
  }
  
  bool V8DOMStringList::hasInstance(v8::Local<v8::Value> v8Value, v8::Isolate* isolate)
  {
      return V8PerIsolateData::from(isolate)->hasInstance(&wrapperTypeInfo, v8Value);
  }
  
  v8::Local<v8::Object> V8DOMStringList::findInstanceInPrototypeChain(v8::Local<v8::Value> v8Value, v8::Isolate* isolate)
  {
      return V8PerIsolateData::from(isolate)->findInstanceInPrototypeChain(&wrapperTypeInfo, v8Value);
  }
  
  DOMStringList* V8DOMStringList::toImplWithTypeCheck(v8::Isolate* isolate, v8::Local<v8::Value> value)
  {
      return hasInstance(value, isolate) ? toImpl(v8::Local<v8::Object>::Cast(value)) : 0;
  }
  
  void V8DOMStringList::refObject(ScriptWrappable* scriptWrappable)
  {
  #if !ENABLE(OILPAN)
      scriptWrappable->toImpl<DOMStringList>()->ref();
  #endif
  }
  
  void V8DOMStringList::derefObject(ScriptWrappable* scriptWrappable)
  {
  #if !ENABLE(OILPAN)
      scriptWrappable->toImpl<DOMStringList>()->deref();
  #endif
  }
  
  } // namespace blink
  