/work/obj-fuzz/dom/bindings/KeyframeAnimationOptionsBinding.cpp

Source (jump to first uncovered line)
/* THIS FILE IS AUTOGENERATED FROM KeyframeAnimationOptions.webidl BY Codegen.py - DO NOT EDIT */

#include "KeyframeAnimationOptionsBinding.h"
#include "mozilla/dom/NonRefcountedDOMObject.h"
#include "mozilla/dom/PrimitiveConversions.h"

namespace mozilla {
namespace dom {

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


bool
UnrestrictedDoubleOrKeyframeAnimationOptions::ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const
{
  switch (mType) {
    case eUninitialized: {
      return false;
      break;
    }
    case eUnrestrictedDouble: {
      rval.set(JS_NumberValue(double(mValue.mUnrestrictedDouble.Value())));
      return true;
      break;
    }
    case eKeyframeAnimationOptions: {
      if (!mValue.mKeyframeAnimationOptions.Value().ToObjectInternal(cx, rval)) {
        return false;
      }
      return true;
      break;
    }
    default: {
      return false;
      break;
    }
  }

  return false;
}


double&
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::RawSetAsUnrestrictedDouble()
{
  if (mType == eUnrestrictedDouble) {
    return mValue.mUnrestrictedDouble.Value();
  }
  MOZ_ASSERT(mType == eUninitialized);
  mType = eUnrestrictedDouble;
  return mValue.mUnrestrictedDouble.SetValue();
}

double&
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::SetAsUnrestrictedDouble()
{
  if (mType == eUnrestrictedDouble) {
    return mValue.mUnrestrictedDouble.Value();
  }
  Uninit();
  mType = eUnrestrictedDouble;
  return mValue.mUnrestrictedDouble.SetValue();
}

bool
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::TrySetToUnrestrictedDouble(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl)
{
  tryNext = false;
  { // scope for memberSlot
    double& memberSlot = RawSetAsUnrestrictedDouble();
    if (!ValueToPrimitive<double, eDefault>(cx, value, &memberSlot)) {
      return false;
    }
  }
  return true;
}

void
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::DestroyUnrestrictedDouble()
{
  MOZ_ASSERT(IsUnrestrictedDouble(), "Wrong type!");
  mValue.mUnrestrictedDouble.Destroy();
  mType = eUninitialized;
}




KeyframeAnimationOptions&
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::RawSetAsKeyframeAnimationOptions()
{
  if (mType == eKeyframeAnimationOptions) {
    return mValue.mKeyframeAnimationOptions.Value();
  }
  MOZ_ASSERT(mType == eUninitialized);
  mType = eKeyframeAnimationOptions;
  return mValue.mKeyframeAnimationOptions.SetValue();
}

KeyframeAnimationOptions&
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::SetAsKeyframeAnimationOptions()
{
  if (mType == eKeyframeAnimationOptions) {
    return mValue.mKeyframeAnimationOptions.Value();
  }
  Uninit();
  mType = eKeyframeAnimationOptions;
  return mValue.mKeyframeAnimationOptions.SetValue();
}

bool
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::TrySetToKeyframeAnimationOptions(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl)
{
  tryNext = false;
  { // scope for memberSlot
    KeyframeAnimationOptions& memberSlot = RawSetAsKeyframeAnimationOptions();
    if (!IsConvertibleToDictionary(value)) {
      DestroyKeyframeAnimationOptions();
      tryNext = true;
      return true;
    }
    if (!memberSlot.Init(cx, value,  "Member of UnrestrictedDoubleOrKeyframeAnimationOptions", passedToJSImpl)) {
      return false;
    }
  }
  return true;
}

void
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::DestroyKeyframeAnimationOptions()
{
  MOZ_ASSERT(IsKeyframeAnimationOptions(), "Wrong type!");
  mValue.mKeyframeAnimationOptions.Destroy();
  mType = eUninitialized;
}




void
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::Uninit()
{
  switch (mType) {
    case eUninitialized: {
      break;
    }
    case eUnrestrictedDouble: {
      DestroyUnrestrictedDouble();
      break;
    }
    case eKeyframeAnimationOptions: {
      DestroyKeyframeAnimationOptions();
      break;
    }
  }
}

bool
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const
{
  switch (mType) {
    case eUninitialized: {
      return false;
      break;
    }
    case eUnrestrictedDouble: {
      rval.set(JS_NumberValue(double(mValue.mUnrestrictedDouble.Value())));
      return true;
      break;
    }
    case eKeyframeAnimationOptions: {
      if (!mValue.mKeyframeAnimationOptions.Value().ToObjectInternal(cx, rval)) {
        return false;
      }
      return true;
      break;
    }
    default: {
      return false;
      break;
    }
  }

  return false;
}

void
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::TraceUnion(JSTracer* trc)
{
}

OwningUnrestrictedDoubleOrKeyframeAnimationOptions&
OwningUnrestrictedDoubleOrKeyframeAnimationOptions::operator=(const OwningUnrestrictedDoubleOrKeyframeAnimationOptions& aOther)
{
  switch (aOther.mType) {
    case eUninitialized: {
      MOZ_ASSERT(mType == eUninitialized,
                 "We need to destroy ourselves?");
      break;
    }
    case eUnrestrictedDouble: {
      SetAsUnrestrictedDouble() = aOther.GetAsUnrestrictedDouble();
      break;
    }
    case eKeyframeAnimationOptions: {
      SetAsKeyframeAnimationOptions() = aOther.GetAsKeyframeAnimationOptions();
      break;
    }
  }
  return *this;
}


} // namespace dom
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		/* THIS FILE IS AUTOGENERATED FROM KeyframeAnimationOptions.webidl BY Codegen.py - DO NOT EDIT */
2
3		#include "KeyframeAnimationOptionsBinding.h"
4		#include "mozilla/dom/NonRefcountedDOMObject.h"
5		#include "mozilla/dom/PrimitiveConversions.h"
6
7		namespace mozilla {
8		namespace dom {
9
10		namespace binding_detail {}; // Just to make sure it's known as a namespace
11		using namespace mozilla::dom::binding_detail;
12
13
14		bool
15		UnrestrictedDoubleOrKeyframeAnimationOptions::ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const
16	0	{
17	0	switch (mType) {
18	0	case eUninitialized: {
19	0	return false;
20	0	break;
21	0	}
22	0	case eUnrestrictedDouble: {
23	0	rval.set(JS_NumberValue(double(mValue.mUnrestrictedDouble.Value())));
24	0	return true;
25	0	break;
26	0	}
27	0	case eKeyframeAnimationOptions: {
28	0	if (!mValue.mKeyframeAnimationOptions.Value().ToObjectInternal(cx, rval)) {
29	0	return false;
30	0	}
31	0	return true;
32	0	break;
33	0	}
34	0	default: {
35	0	return false;
36	0	break;
37	0	}
38	0	}
39	0
40	0	return false;
41	0	}
42
43
44		double&
45		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::RawSetAsUnrestrictedDouble()
46	0	{
47	0	if (mType == eUnrestrictedDouble) {
48	0	return mValue.mUnrestrictedDouble.Value();
49	0	}
50	0	MOZ_ASSERT(mType == eUninitialized);
51	0	mType = eUnrestrictedDouble;
52	0	return mValue.mUnrestrictedDouble.SetValue();
53	0	}
54
55		double&
56		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::SetAsUnrestrictedDouble()
57	0	{
58	0	if (mType == eUnrestrictedDouble) {
59	0	return mValue.mUnrestrictedDouble.Value();
60	0	}
61	0	Uninit();
62	0	mType = eUnrestrictedDouble;
63	0	return mValue.mUnrestrictedDouble.SetValue();
64	0	}
65
66		bool
67		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::TrySetToUnrestrictedDouble(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl)
68	0	{
69	0	tryNext = false;
70	0	{ // scope for memberSlot
71	0	double& memberSlot = RawSetAsUnrestrictedDouble();
72	0	if (!ValueToPrimitive<double, eDefault>(cx, value, &memberSlot)) {
73	0	return false;
74	0	}
75	0	}
76	0	return true;
77	0	}
78
79		void
80		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::DestroyUnrestrictedDouble()
81	0	{
82	0	MOZ_ASSERT(IsUnrestrictedDouble(), "Wrong type!");
83	0	mValue.mUnrestrictedDouble.Destroy();
84	0	mType = eUninitialized;
85	0	}
86
87
88
89
90		KeyframeAnimationOptions&
91		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::RawSetAsKeyframeAnimationOptions()
92	0	{
93	0	if (mType == eKeyframeAnimationOptions) {
94	0	return mValue.mKeyframeAnimationOptions.Value();
95	0	}
96	0	MOZ_ASSERT(mType == eUninitialized);
97	0	mType = eKeyframeAnimationOptions;
98	0	return mValue.mKeyframeAnimationOptions.SetValue();
99	0	}
100
101		KeyframeAnimationOptions&
102		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::SetAsKeyframeAnimationOptions()
103	0	{
104	0	if (mType == eKeyframeAnimationOptions) {
105	0	return mValue.mKeyframeAnimationOptions.Value();
106	0	}
107	0	Uninit();
108	0	mType = eKeyframeAnimationOptions;
109	0	return mValue.mKeyframeAnimationOptions.SetValue();
110	0	}
111
112		bool
113		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::TrySetToKeyframeAnimationOptions(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl)
114	0	{
115	0	tryNext = false;
116	0	{ // scope for memberSlot
117	0	KeyframeAnimationOptions& memberSlot = RawSetAsKeyframeAnimationOptions();
118	0	if (!IsConvertibleToDictionary(value)) {
119	0	DestroyKeyframeAnimationOptions();
120	0	tryNext = true;
121	0	return true;
122	0	}
123	0	if (!memberSlot.Init(cx, value, "Member of UnrestrictedDoubleOrKeyframeAnimationOptions", passedToJSImpl)) {
124	0	return false;
125	0	}
126	0	}
127	0	return true;
128	0	}
129
130		void
131		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::DestroyKeyframeAnimationOptions()
132	0	{
133	0	MOZ_ASSERT(IsKeyframeAnimationOptions(), "Wrong type!");
134	0	mValue.mKeyframeAnimationOptions.Destroy();
135	0	mType = eUninitialized;
136	0	}
137
138
139
140
141		void
142		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::Uninit()
143		{
144		switch (mType) {
145		case eUninitialized: {
146		break;
147		}
148		case eUnrestrictedDouble: {
149		DestroyUnrestrictedDouble();
150		break;
151		}
152		case eKeyframeAnimationOptions: {
153		DestroyKeyframeAnimationOptions();
154		break;
155		}
156		}
157		}
158
159		bool
160		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const
161	0	{
162	0	switch (mType) {
163	0	case eUninitialized: {
164	0	return false;
165	0	break;
166	0	}
167	0	case eUnrestrictedDouble: {
168	0	rval.set(JS_NumberValue(double(mValue.mUnrestrictedDouble.Value())));
169	0	return true;
170	0	break;
171	0	}
172	0	case eKeyframeAnimationOptions: {
173	0	if (!mValue.mKeyframeAnimationOptions.Value().ToObjectInternal(cx, rval)) {
174	0	return false;
175	0	}
176	0	return true;
177	0	break;
178	0	}
179	0	default: {
180	0	return false;
181	0	break;
182	0	}
183	0	}
184	0
185	0	return false;
186	0	}
187
188		void
189		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::TraceUnion(JSTracer* trc)
190	0	{
191	0	}
192
193		OwningUnrestrictedDoubleOrKeyframeAnimationOptions&
194		OwningUnrestrictedDoubleOrKeyframeAnimationOptions::operator=(const OwningUnrestrictedDoubleOrKeyframeAnimationOptions& aOther)
195	0	{
196	0	switch (aOther.mType) {
197	0	case eUninitialized: {
198	0	MOZ_ASSERT(mType == eUninitialized,
199	0	"We need to destroy ourselves?");
200	0	break;
201	0	}
202	0	case eUnrestrictedDouble: {
203	0	SetAsUnrestrictedDouble() = aOther.GetAsUnrestrictedDouble();
204	0	break;
205	0	}
206	0	case eKeyframeAnimationOptions: {
207	0	SetAsKeyframeAnimationOptions() = aOther.GetAsKeyframeAnimationOptions();
208	0	break;
209	0	}
210	0	}
211	0	return *this;
212	0	}
213
214
215		} // namespace dom
216		} // namespace mozilla