/* THIS FILE IS AUTOGENERATED FROM Promise.webidl BY Codegen.py - DO NOT EDIT */

#include "PromiseBinding.h"

#include "WrapperFactory.h"

#include "mozilla/OwningNonNull.h"

#include "mozilla/dom/BindingUtils.h"

#include "mozilla/dom/DOMJSClass.h"

#include "mozilla/dom/NonRefcountedDOMObject.h"

#include "mozilla/dom/PromiseNativeHandler.h"

#include "mozilla/dom/XrayExpandoClass.h"

namespace mozilla {

namespace dom {

namespace binding_detail {}; // Just to make sure it's known as a namespace

using namespace mozilla::dom::binding_detail;

void

PromiseJobCallback::Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, ErrorResult& aRv)

{

  JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());

  JS::Rooted<JS::Value> callable(cx, JS::ObjectValue(*mCallback));

  if (!JS::Call(cx, aThisVal, callable,

                JS::HandleValueArray::empty(), &rval)) {

    aRv.NoteJSContextException(cx);

    return;

  }

}

void

AnyCallback::Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, JS::Handle<JS::Value> value, JS::MutableHandle<JS::Value> aRetVal, ErrorResult& aRv)

{

  JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());

  JS::AutoValueVector argv(cx);

  if (!argv.resize(1)) {

    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);

    return;

  }

  unsigned argc = 1;

  do {

    JS::ExposeValueToActiveJS(value);

    argv[0].set(value);

    if (!MaybeWrapValue(cx, argv[0])) {

      aRv.Throw(NS_ERROR_UNEXPECTED);

      return;

    }

    break;

  } while (false);

  JS::Rooted<JS::Value> callable(cx, JS::ObjectValue(*mCallback));

  if (!JS::Call(cx, aThisVal, callable,

                JS::HandleValueArray::subarray(argv, 0, argc), &rval)) {

    aRv.NoteJSContextException(cx);

    return;

  }

  JS::Rooted<JS::Value> rvalDecl(cx);

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunreachable-code"

#pragma clang diagnostic ignored "-Wunreachable-code-return"

#endif // __clang__

  if ((false) && !CallerSubsumes(rval)) {

    ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "return value of AnyCallback");

    aRv.Throw(NS_ERROR_UNEXPECTED);

    return;

  }

#ifdef __clang__

#pragma clang diagnostic pop

#endif // __clang__

  rvalDecl = rval;

  aRetVal.set(rvalDecl);

}

namespace binding_detail {

} // namespace binding_detail

namespace binding_detail {

} // namespace binding_detail

namespace PromiseNativeHandler_Binding {

static void

_finalize(js::FreeOp* fop, JSObject* obj)

{

  mozilla::dom::PromiseNativeHandler* self = UnwrapPossiblyNotInitializedDOMObject<mozilla::dom::PromiseNativeHandler>(obj);

  if (self) {

    AddForDeferredFinalization<mozilla::dom::PromiseNativeHandler>(self);

  }

}

static const DOMIfaceAndProtoJSClass sPrototypeClass = {

  {

    "PromiseNativeHandlerPrototype",

    JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(DOM_INTERFACE_PROTO_SLOTS_BASE),

    JS_NULL_CLASS_OPS,

    JS_NULL_CLASS_SPEC,

    JS_NULL_CLASS_EXT,

    JS_NULL_OBJECT_OPS

  },

  eInterfacePrototype,

  false,

  prototypes::id::PromiseNativeHandler,

  PrototypeTraits<prototypes::id::PromiseNativeHandler>::Depth,

  sNativePropertyHooks,

  "[object PromiseNativeHandlerPrototype]",

  JS::GetRealmObjectPrototype

};

static const js::ClassOps sClassOps = {

  nullptr, /* addProperty */

  nullptr,               /* delProperty */

  nullptr,               /* enumerate */

  nullptr, /* newEnumerate */

  nullptr, /* resolve */

  nullptr, /* mayResolve */

  _finalize, /* finalize */

  nullptr, /* call */

  nullptr,               /* hasInstance */

  nullptr,               /* construct */

  nullptr, /* trace */

};

static const js::ClassExtension sClassExtension = {

  nullptr, /* weakmapKeyDelegateOp */

  nullptr /* objectMovedOp */

};

static const DOMJSClass sClass = {

  { "PromiseNativeHandler",

    JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE | JSCLASS_HAS_RESERVED_SLOTS(1),

    &sClassOps,

    JS_NULL_CLASS_SPEC,

    &sClassExtension,

    JS_NULL_OBJECT_OPS

  },

  { prototypes::id::PromiseNativeHandler, prototypes::id::_ID_Count, prototypes::id::_ID_Count, prototypes::id::_ID_Count, prototypes::id::_ID_Count, prototypes::id::_ID_Count, prototypes::id::_ID_Count, prototypes::id::_ID_Count },

  IsBaseOf<nsISupports, mozilla::dom::PromiseNativeHandler >::value,

  sNativePropertyHooks,

  FindAssociatedGlobalForNative<mozilla::dom::PromiseNativeHandler>::Get,

  GetProtoObjectHandle,

  GetCCParticipant<mozilla::dom::PromiseNativeHandler>::Get()

};

static_assert(1 == DOM_INSTANCE_RESERVED_SLOTS,

              "Must have the right minimal number of reserved slots.");

static_assert(1 >= 1,

              "Must have enough reserved slots.");

const JSClass*

GetJSClass()

{

  return sClass.ToJSClass();

}

bool

Wrap(JSContext* aCx, mozilla::dom::PromiseNativeHandler* aObject, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector)

{

  MOZ_ASSERT(static_cast<mozilla::dom::PromiseNativeHandler*>(aObject) ==

             reinterpret_cast<mozilla::dom::PromiseNativeHandler*>(aObject),

             "Multiple inheritance for mozilla::dom::PromiseNativeHandler is broken.");

  MOZ_ASSERT(ToSupportsIsCorrect(aObject));

  MOZ_ASSERT_IF(aGivenProto, js::IsObjectInContextCompartment(aGivenProto, aCx));

  JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));

  JS::Handle<JSObject*> canonicalProto = GetProtoObjectHandle(aCx);

  if (!canonicalProto) {

    return false;

  }

  JS::Rooted<JSObject*> proto(aCx);

  if (aGivenProto) {

    proto = aGivenProto;

    // Unfortunately, while aGivenProto was in the compartment of aCx

    // coming in, we changed compartments to that of "parent" so may need

    // to wrap the proto here.

    if (js::GetContextCompartment(aCx) != js::GetObjectCompartment(proto)) {

      if (!JS_WrapObject(aCx, &proto)) {

        return false;

      }

    }

  } else {

    proto = canonicalProto;

  }

  BindingJSObjectCreator<mozilla::dom::PromiseNativeHandler> creator(aCx);

  creator.CreateObject(aCx, sClass.ToJSClass(), proto, aObject, aReflector);

  if (!aReflector) {

    return false;

  }

  creator.InitializationSucceeded();

  return true;

}

const NativePropertyHooks sNativePropertyHooks[] = { {

  nullptr,

  nullptr,

  nullptr,

  { nullptr, nullptr },

  prototypes::id::PromiseNativeHandler,

  constructors::id::_ID_Count,

  nullptr,

  &DefaultXrayExpandoObjectClass

} };

void

CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal)

{

  JS::Rooted<JSObject*> parentProto(aCx, JS::GetRealmObjectPrototype(aCx));

  if (!parentProto) {

    return;

  }

  JS::Heap<JSObject*>* protoCache = &aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::PromiseNativeHandler);

  JS::Heap<JSObject*>* interfaceCache = nullptr;

  dom::CreateInterfaceObjects(aCx, aGlobal, parentProto,

                              &sPrototypeClass.mBase, protoCache,

                              nullptr,

                              nullptr, nullptr, 0, nullptr,

                              interfaceCache,

                              nullptr,

                              nullptr,

                              nullptr, aDefineOnGlobal,

                              nullptr,

                              false);

}

} // namespace PromiseNativeHandler_Binding

} // namespace dom

} // namespace mozilla