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

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

#include "AtomList.h"
#include "ProfileTimelineMarkerBinding.h"
#include "jsapi.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/OwningNonNull.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/dom/NonRefcountedDOMObject.h"
#include "mozilla/dom/PrimitiveConversions.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/SimpleGlobalObject.h"

namespace mozilla {
namespace dom {

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


namespace ProfileTimelineMessagePortOperationTypeValues {
extern const EnumEntry strings[3] = {
  {"serializeData", 13},
  {"deserializeData", 15},
  { nullptr, 0 }
};
} // namespace ProfileTimelineMessagePortOperationTypeValues

bool
ToJSValue(JSContext* aCx, ProfileTimelineMessagePortOperationType aArgument, JS::MutableHandle<JS::Value> aValue)
{
  MOZ_ASSERT(uint32_t(aArgument) < ArrayLength(ProfileTimelineMessagePortOperationTypeValues::strings));
  JSString* resultStr =
    JS_NewStringCopyN(aCx, ProfileTimelineMessagePortOperationTypeValues::strings[uint32_t(aArgument)].value,
                      ProfileTimelineMessagePortOperationTypeValues::strings[uint32_t(aArgument)].length);
  if (!resultStr) {
    return false;
  }
  aValue.setString(resultStr);
  return true;
}


namespace ProfileTimelineWorkerOperationTypeValues {
extern const EnumEntry strings[5] = {
  {"serializeDataOffMainThread", 26},
  {"serializeDataOnMainThread", 25},
  {"deserializeDataOffMainThread", 28},
  {"deserializeDataOnMainThread", 27},
  { nullptr, 0 }
};
} // namespace ProfileTimelineWorkerOperationTypeValues

bool
ToJSValue(JSContext* aCx, ProfileTimelineWorkerOperationType aArgument, JS::MutableHandle<JS::Value> aValue)
{
  MOZ_ASSERT(uint32_t(aArgument) < ArrayLength(ProfileTimelineWorkerOperationTypeValues::strings));
  JSString* resultStr =
    JS_NewStringCopyN(aCx, ProfileTimelineWorkerOperationTypeValues::strings[uint32_t(aArgument)].value,
                      ProfileTimelineWorkerOperationTypeValues::strings[uint32_t(aArgument)].length);
  if (!resultStr) {
    return false;
  }
  aValue.setString(resultStr);
  return true;
}



ProfileTimelineLayerRect::ProfileTimelineLayerRect()
{
  // Safe to pass a null context if we pass a null value
  Init(nullptr, JS::NullHandleValue);
}



bool
ProfileTimelineLayerRect::InitIds(JSContext* cx, ProfileTimelineLayerRectAtoms* atomsCache)
{
  MOZ_ASSERT(!*reinterpret_cast<jsid**>(atomsCache));

  // Initialize these in reverse order so that any failure leaves the first one
  // uninitialized.
  if (!atomsCache->y_id.init(cx, "y") ||
      !atomsCache->x_id.init(cx, "x") ||
      !atomsCache->width_id.init(cx, "width") ||
      !atomsCache->height_id.init(cx, "height")) {
    return false;
  }
  return true;
}

bool
ProfileTimelineLayerRect::Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription, bool passedToJSImpl)
{
  // Passing a null JSContext is OK only if we're initing from null,
  // Since in that case we will not have to do any property gets
  // Also evaluate isNullOrUndefined in order to avoid false-positive
  // checkers by static analysis tools
  MOZ_ASSERT_IF(!cx, val.isNull() && val.isNullOrUndefined());
  ProfileTimelineLayerRectAtoms* atomsCache = nullptr;
  if (cx) {
    atomsCache = GetAtomCache<ProfileTimelineLayerRectAtoms>(cx);
    if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
      return false;
    }
  }

  if (!IsConvertibleToDictionary(val)) {
    return ThrowErrorMessage(cx, MSG_NOT_DICTIONARY, sourceDescription);
  }

  bool isNull = val.isNullOrUndefined();
  // We only need these if !isNull, in which case we have |cx|.
  Maybe<JS::Rooted<JSObject *> > object;
  Maybe<JS::Rooted<JS::Value> > temp;
  if (!isNull) {
    MOZ_ASSERT(cx);
    object.emplace(cx, &val.toObject());
    temp.emplace(cx);
  }
  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->height_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<int32_t, eDefault>(cx, temp.ref(), &mHeight)) {
      return false;
    }
  } else {
    mHeight = 0;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->width_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<int32_t, eDefault>(cx, temp.ref(), &mWidth)) {
      return false;
    }
  } else {
    mWidth = 0;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->x_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<int32_t, eDefault>(cx, temp.ref(), &mX)) {
      return false;
    }
  } else {
    mX = 0;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->y_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<int32_t, eDefault>(cx, temp.ref(), &mY)) {
      return false;
    }
  } else {
    mY = 0;
  }
  mIsAnyMemberPresent = true;
  return true;
}

bool
ProfileTimelineLayerRect::Init(const nsAString& aJSON)
{
  AutoJSAPI jsapi;
  JSObject* cleanGlobal = SimpleGlobalObject::Create(SimpleGlobalObject::GlobalType::BindingDetail);
  if (!cleanGlobal) {
    return false;
  }
  if (!jsapi.Init(cleanGlobal)) {
    return false;
  }
  JSContext* cx = jsapi.cx();
  JS::Rooted<JS::Value> json(cx);
  bool ok = ParseJSON(cx, aJSON, &json);
  NS_ENSURE_TRUE(ok, false);
  return Init(cx, json);
}

bool
ProfileTimelineLayerRect::ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const
{
  ProfileTimelineLayerRectAtoms* atomsCache = GetAtomCache<ProfileTimelineLayerRectAtoms>(cx);
  if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
    return false;
  }

  JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx));
  if (!obj) {
    return false;
  }
  rval.set(JS::ObjectValue(*obj));

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    int32_t const & currentValue = mHeight;
    temp.setInt32(int32_t(currentValue));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->height_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    int32_t const & currentValue = mWidth;
    temp.setInt32(int32_t(currentValue));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->width_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    int32_t const & currentValue = mX;
    temp.setInt32(int32_t(currentValue));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->x_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    int32_t const & currentValue = mY;
    temp.setInt32(int32_t(currentValue));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->y_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  return true;
}

bool
ProfileTimelineLayerRect::ToJSON(nsAString& aJSON) const
{
  AutoJSAPI jsapi;
  jsapi.Init();
  JSContext *cx = jsapi.cx();
  // It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here
  // because we'll only be creating objects, in ways that have no
  // side-effects, followed by a call to JS::ToJSONMaybeSafely,
  // which likewise guarantees no side-effects for the sorts of
  // things we will pass it.
  JSAutoRealm ar(cx, UnprivilegedJunkScopeOrWorkerGlobal());
  JS::Rooted<JS::Value> val(cx);
  if (!ToObjectInternal(cx, &val)) {
    return false;
  }
  JS::Rooted<JSObject*> obj(cx, &val.toObject());
  return StringifyToJSON(cx, obj, aJSON);
}

void
ProfileTimelineLayerRect::TraceDictionary(JSTracer* trc)
{
}

ProfileTimelineLayerRect&
ProfileTimelineLayerRect::operator=(const ProfileTimelineLayerRect& aOther)
{
  DictionaryBase::operator=(aOther);
  mHeight = aOther.mHeight;
  mWidth = aOther.mWidth;
  mX = aOther.mX;
  mY = aOther.mY;
  return *this;
}

namespace binding_detail {
} // namespace binding_detail



ProfileTimelineStackFrame::ProfileTimelineStackFrame()
  : mAsyncParent(nullptr),
    mParent(nullptr)
{
  // Safe to pass a null context if we pass a null value
  Init(nullptr, JS::NullHandleValue);
}


bool
ProfileTimelineStackFrame::InitIds(JSContext* cx, ProfileTimelineStackFrameAtoms* atomsCache)
{
  MOZ_ASSERT(!*reinterpret_cast<jsid**>(atomsCache));

  // Initialize these in reverse order so that any failure leaves the first one
  // uninitialized.
  if (!atomsCache->source_id.init(cx, "source") ||
      !atomsCache->parent_id.init(cx, "parent") ||
      !atomsCache->line_id.init(cx, "line") ||
      !atomsCache->functionDisplayName_id.init(cx, "functionDisplayName") ||
      !atomsCache->column_id.init(cx, "column") ||
      !atomsCache->asyncParent_id.init(cx, "asyncParent") ||
      !atomsCache->asyncCause_id.init(cx, "asyncCause")) {
    return false;
  }
  return true;
}

bool
ProfileTimelineStackFrame::Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription, bool passedToJSImpl)
{
  // Passing a null JSContext is OK only if we're initing from null,
  // Since in that case we will not have to do any property gets
  // Also evaluate isNullOrUndefined in order to avoid false-positive
  // checkers by static analysis tools
  MOZ_ASSERT_IF(!cx, val.isNull() && val.isNullOrUndefined());
  ProfileTimelineStackFrameAtoms* atomsCache = nullptr;
  if (cx) {
    atomsCache = GetAtomCache<ProfileTimelineStackFrameAtoms>(cx);
    if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
      return false;
    }
  }

  if (!IsConvertibleToDictionary(val)) {
    return ThrowErrorMessage(cx, MSG_NOT_DICTIONARY, sourceDescription);
  }

  bool isNull = val.isNullOrUndefined();
  // We only need these if !isNull, in which case we have |cx|.
  Maybe<JS::Rooted<JSObject *> > object;
  Maybe<JS::Rooted<JS::Value> > temp;
  if (!isNull) {
    MOZ_ASSERT(cx);
    object.emplace(cx, &val.toObject());
    temp.emplace(cx);
  }
  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->asyncCause_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mAsyncCause.Construct();
    if (!ConvertJSValueToString(cx, temp.ref(), eStringify, eStringify, (mAsyncCause.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->asyncParent_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (temp.ref().isObject()) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif // __clang__
      if ((passedToJSImpl) && !CallerSubsumes(temp.ref())) {
        ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "'asyncParent' member of ProfileTimelineStackFrame");
        return false;
      }
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
      mAsyncParent = &temp.ref().toObject();
    } else if (temp.ref().isNullOrUndefined()) {
      mAsyncParent = nullptr;
    } else {
      ThrowErrorMessage(cx, MSG_NOT_OBJECT, "'asyncParent' member of ProfileTimelineStackFrame");
      return false;
    }
  } else {
    mAsyncParent = nullptr;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->column_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<int32_t, eDefault>(cx, temp.ref(), &mColumn)) {
      return false;
    }
  } else {
    mColumn = 0;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->functionDisplayName_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mFunctionDisplayName.Construct();
    if (!ConvertJSValueToString(cx, temp.ref(), eStringify, eStringify, (mFunctionDisplayName.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->line_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mLine.Construct();
    if (!ValueToPrimitive<int32_t, eDefault>(cx, temp.ref(), &(mLine.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->parent_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (temp.ref().isObject()) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif // __clang__
      if ((passedToJSImpl) && !CallerSubsumes(temp.ref())) {
        ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "'parent' member of ProfileTimelineStackFrame");
        return false;
      }
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
      mParent = &temp.ref().toObject();
    } else if (temp.ref().isNullOrUndefined()) {
      mParent = nullptr;
    } else {
      ThrowErrorMessage(cx, MSG_NOT_OBJECT, "'parent' member of ProfileTimelineStackFrame");
      return false;
    }
  } else {
    mParent = nullptr;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->source_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mSource.Construct();
    if (!ConvertJSValueToString(cx, temp.ref(), eStringify, eStringify, (mSource.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }
  return true;
}

bool
ProfileTimelineStackFrame::ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const
{
  ProfileTimelineStackFrameAtoms* atomsCache = GetAtomCache<ProfileTimelineStackFrameAtoms>(cx);
  if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
    return false;
  }

  JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx));
  if (!obj) {
    return false;
  }
  rval.set(JS::ObjectValue(*obj));

  if (mAsyncCause.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      nsString const & currentValue = mAsyncCause.InternalValue();
      if (!xpc::NonVoidStringToJsval(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->asyncCause_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    JSObject* const & currentValue = mAsyncParent;
    if (currentValue) {
                  JS::ExposeObjectToActiveJS(currentValue);
                }
                temp.setObjectOrNull(currentValue);
    if (!MaybeWrapObjectOrNullValue(cx, &temp)) {
      return false;
    }
    if (!JS_DefinePropertyById(cx, obj, atomsCache->asyncParent_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    int32_t const & currentValue = mColumn;
    temp.setInt32(int32_t(currentValue));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->column_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  if (mFunctionDisplayName.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      nsString const & currentValue = mFunctionDisplayName.InternalValue();
      if (!xpc::NonVoidStringToJsval(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->functionDisplayName_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mLine.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      int32_t const & currentValue = mLine.InternalValue();
      temp.setInt32(int32_t(currentValue));
      if (!JS_DefinePropertyById(cx, obj, atomsCache->line_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    JSObject* const & currentValue = mParent;
    if (currentValue) {
                  JS::ExposeObjectToActiveJS(currentValue);
                }
                temp.setObjectOrNull(currentValue);
    if (!MaybeWrapObjectOrNullValue(cx, &temp)) {
      return false;
    }
    if (!JS_DefinePropertyById(cx, obj, atomsCache->parent_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  if (mSource.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      nsString const & currentValue = mSource.InternalValue();
      if (!xpc::NonVoidStringToJsval(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->source_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  return true;
}

void
ProfileTimelineStackFrame::TraceDictionary(JSTracer* trc)
{
  if (mAsyncParent) {
    JS::UnsafeTraceRoot(trc, &mAsyncParent, "ProfileTimelineStackFrame.mAsyncParent");
  }

  if (mParent) {
    JS::UnsafeTraceRoot(trc, &mParent, "ProfileTimelineStackFrame.mParent");
  }
}

namespace binding_detail {
} // namespace binding_detail



ProfileTimelineMarker::ProfileTimelineMarker()
  : mEndStack(nullptr),
    mStack(nullptr)
{
  // Safe to pass a null context if we pass a null value
  Init(nullptr, JS::NullHandleValue);
}


bool
ProfileTimelineMarker::InitIds(JSContext* cx, ProfileTimelineMarkerAtoms* atomsCache)
{
  MOZ_ASSERT(!*reinterpret_cast<jsid**>(atomsCache));

  // Initialize these in reverse order so that any failure leaves the first one
  // uninitialized.
  if (!atomsCache->workerOperation_id.init(cx, "workerOperation") ||
      !atomsCache->unixTime_id.init(cx, "unixTime") ||
      !atomsCache->type_id.init(cx, "type") ||
      !atomsCache->start_id.init(cx, "start") ||
      !atomsCache->stack_id.init(cx, "stack") ||
      !atomsCache->rectangles_id.init(cx, "rectangles") ||
      !atomsCache->processType_id.init(cx, "processType") ||
      !atomsCache->name_id.init(cx, "name") ||
      !atomsCache->messagePortOperation_id.init(cx, "messagePortOperation") ||
      !atomsCache->isOffMainThread_id.init(cx, "isOffMainThread") ||
      !atomsCache->isAnimationOnly_id.init(cx, "isAnimationOnly") ||
      !atomsCache->eventPhase_id.init(cx, "eventPhase") ||
      !atomsCache->endStack_id.init(cx, "endStack") ||
      !atomsCache->end_id.init(cx, "end") ||
      !atomsCache->causeName_id.init(cx, "causeName")) {
    return false;
  }
  return true;
}

bool
ProfileTimelineMarker::Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription, bool passedToJSImpl)
{
  // Passing a null JSContext is OK only if we're initing from null,
  // Since in that case we will not have to do any property gets
  // Also evaluate isNullOrUndefined in order to avoid false-positive
  // checkers by static analysis tools
  MOZ_ASSERT_IF(!cx, val.isNull() && val.isNullOrUndefined());
  ProfileTimelineMarkerAtoms* atomsCache = nullptr;
  if (cx) {
    atomsCache = GetAtomCache<ProfileTimelineMarkerAtoms>(cx);
    if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
      return false;
    }
  }

  if (!IsConvertibleToDictionary(val)) {
    return ThrowErrorMessage(cx, MSG_NOT_DICTIONARY, sourceDescription);
  }

  bool isNull = val.isNullOrUndefined();
  // We only need these if !isNull, in which case we have |cx|.
  Maybe<JS::Rooted<JSObject *> > object;
  Maybe<JS::Rooted<JS::Value> > temp;
  if (!isNull) {
    MOZ_ASSERT(cx);
    object.emplace(cx, &val.toObject());
    temp.emplace(cx);
  }
  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->causeName_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mCauseName.Construct();
    if (!ConvertJSValueToString(cx, temp.ref(), eStringify, eStringify, (mCauseName.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->end_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<double, eDefault>(cx, temp.ref(), &mEnd)) {
      return false;
    } else if (!mozilla::IsFinite(mEnd)) {
      ThrowErrorMessage(cx, MSG_NOT_FINITE, "'end' member of ProfileTimelineMarker");
      return false;
    }
  } else {
    mEnd = 0.0;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->endStack_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (temp.ref().isObject()) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif // __clang__
      if ((passedToJSImpl) && !CallerSubsumes(temp.ref())) {
        ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "'endStack' member of ProfileTimelineMarker");
        return false;
      }
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
      mEndStack = &temp.ref().toObject();
    } else if (temp.ref().isNullOrUndefined()) {
      mEndStack = nullptr;
    } else {
      ThrowErrorMessage(cx, MSG_NOT_OBJECT, "'endStack' member of ProfileTimelineMarker");
      return false;
    }
  } else {
    mEndStack = nullptr;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->eventPhase_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mEventPhase.Construct();
    if (!ValueToPrimitive<uint16_t, eDefault>(cx, temp.ref(), &(mEventPhase.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->isAnimationOnly_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mIsAnimationOnly.Construct();
    if (!ValueToPrimitive<bool, eDefault>(cx, temp.ref(), &(mIsAnimationOnly.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->isOffMainThread_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mIsOffMainThread.Construct();
    if (!ValueToPrimitive<bool, eDefault>(cx, temp.ref(), &(mIsOffMainThread.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->messagePortOperation_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mMessagePortOperation.Construct();
    {
      int index;
      if (!FindEnumStringIndex<true>(cx, temp.ref(), ProfileTimelineMessagePortOperationTypeValues::strings, "ProfileTimelineMessagePortOperationType", "'messagePortOperation' member of ProfileTimelineMarker", &index)) {
        return false;
      }
      MOZ_ASSERT(index >= 0);
      (mMessagePortOperation.Value()) = static_cast<ProfileTimelineMessagePortOperationType>(index);
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->name_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ConvertJSValueToString(cx, temp.ref(), eStringify, eStringify, mName)) {
      return false;
    }
  } else {
    static const char16_t data[] = { 0 };
    mName.Rebind(data, ArrayLength(data) - 1);
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->processType_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mProcessType.Construct();
    if (!ValueToPrimitive<uint16_t, eDefault>(cx, temp.ref(), &(mProcessType.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->rectangles_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mRectangles.Construct();
    if (temp.ref().isObject()) {
      JS::ForOfIterator iter(cx);
      if (!iter.init(temp.ref(), JS::ForOfIterator::AllowNonIterable)) {
        return false;
      }
      if (!iter.valueIsIterable()) {
        ThrowErrorMessage(cx, MSG_NOT_SEQUENCE, "'rectangles' member of ProfileTimelineMarker");
        return false;
      }
      Sequence<ProfileTimelineLayerRect> &arr = (mRectangles.Value());
      JS::Rooted<JS::Value> temp(cx);
      while (true) {
        bool done;
        if (!iter.next(&temp, &done)) {
          return false;
        }
        if (done) {
          break;
        }
        ProfileTimelineLayerRect* slotPtr = arr.AppendElement(mozilla::fallible);
        if (!slotPtr) {
          JS_ReportOutOfMemory(cx);
          return false;
        }
        ProfileTimelineLayerRect& slot = *slotPtr;
        if (!slot.Init(cx, temp,  "Element of 'rectangles' member of ProfileTimelineMarker", passedToJSImpl)) {
          return false;
        }
      }
    } else {
      ThrowErrorMessage(cx, MSG_NOT_SEQUENCE, "'rectangles' member of ProfileTimelineMarker");
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->stack_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (temp.ref().isObject()) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif // __clang__
      if ((passedToJSImpl) && !CallerSubsumes(temp.ref())) {
        ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "'stack' member of ProfileTimelineMarker");
        return false;
      }
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
      mStack = &temp.ref().toObject();
    } else if (temp.ref().isNullOrUndefined()) {
      mStack = nullptr;
    } else {
      ThrowErrorMessage(cx, MSG_NOT_OBJECT, "'stack' member of ProfileTimelineMarker");
      return false;
    }
  } else {
    mStack = nullptr;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->start_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    if (!ValueToPrimitive<double, eDefault>(cx, temp.ref(), &mStart)) {
      return false;
    } else if (!mozilla::IsFinite(mStart)) {
      ThrowErrorMessage(cx, MSG_NOT_FINITE, "'start' member of ProfileTimelineMarker");
      return false;
    }
  } else {
    mStart = 0.0;
  }
  mIsAnyMemberPresent = true;

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->type_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mType.Construct();
    if (!ConvertJSValueToString(cx, temp.ref(), eStringify, eStringify, (mType.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->unixTime_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mUnixTime.Construct();
    if (!ValueToPrimitive<uint64_t, eDefault>(cx, temp.ref(), &(mUnixTime.Value()))) {
      return false;
    }
    mIsAnyMemberPresent = true;
  }

  if (!isNull) {
    if (!JS_GetPropertyById(cx, *object, atomsCache->workerOperation_id, temp.ptr())) {
      return false;
    }
  }
  if (!isNull && !temp->isUndefined()) {
    mWorkerOperation.Construct();
    {
      int index;
      if (!FindEnumStringIndex<true>(cx, temp.ref(), ProfileTimelineWorkerOperationTypeValues::strings, "ProfileTimelineWorkerOperationType", "'workerOperation' member of ProfileTimelineMarker", &index)) {
        return false;
      }
      MOZ_ASSERT(index >= 0);
      (mWorkerOperation.Value()) = static_cast<ProfileTimelineWorkerOperationType>(index);
    }
    mIsAnyMemberPresent = true;
  }
  return true;
}

bool
ProfileTimelineMarker::ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const
{
  ProfileTimelineMarkerAtoms* atomsCache = GetAtomCache<ProfileTimelineMarkerAtoms>(cx);
  if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
    return false;
  }

  JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx));
  if (!obj) {
    return false;
  }
  rval.set(JS::ObjectValue(*obj));

  if (mCauseName.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      nsString const & currentValue = mCauseName.InternalValue();
      if (!xpc::NonVoidStringToJsval(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->causeName_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    double const & currentValue = mEnd;
    temp.set(JS_NumberValue(double(currentValue)));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->end_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    JSObject* const & currentValue = mEndStack;
    if (currentValue) {
                  JS::ExposeObjectToActiveJS(currentValue);
                }
                temp.setObjectOrNull(currentValue);
    if (!MaybeWrapObjectOrNullValue(cx, &temp)) {
      return false;
    }
    if (!JS_DefinePropertyById(cx, obj, atomsCache->endStack_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  if (mEventPhase.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      uint16_t const & currentValue = mEventPhase.InternalValue();
      temp.setInt32(int32_t(currentValue));
      if (!JS_DefinePropertyById(cx, obj, atomsCache->eventPhase_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mIsAnimationOnly.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      bool const & currentValue = mIsAnimationOnly.InternalValue();
      temp.setBoolean(currentValue);
      if (!JS_DefinePropertyById(cx, obj, atomsCache->isAnimationOnly_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mIsOffMainThread.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      bool const & currentValue = mIsOffMainThread.InternalValue();
      temp.setBoolean(currentValue);
      if (!JS_DefinePropertyById(cx, obj, atomsCache->isOffMainThread_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mMessagePortOperation.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      ProfileTimelineMessagePortOperationType const & currentValue = mMessagePortOperation.InternalValue();
      if (!ToJSValue(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->messagePortOperation_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    nsString const & currentValue = mName;
    if (!xpc::NonVoidStringToJsval(cx, currentValue, &temp)) {
      return false;
    }
    if (!JS_DefinePropertyById(cx, obj, atomsCache->name_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  if (mProcessType.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      uint16_t const & currentValue = mProcessType.InternalValue();
      temp.setInt32(int32_t(currentValue));
      if (!JS_DefinePropertyById(cx, obj, atomsCache->processType_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mRectangles.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      Sequence<ProfileTimelineLayerRect> const & currentValue = mRectangles.InternalValue();

      uint32_t length = currentValue.Length();
      JS::Rooted<JSObject*> returnArray(cx, JS_NewArrayObject(cx, length));
      if (!returnArray) {
        return false;
      }
      // Scope for 'tmp'
      {
        JS::Rooted<JS::Value> tmp(cx);
        for (uint32_t sequenceIdx0 = 0; sequenceIdx0 < length; ++sequenceIdx0) {
          // Control block to let us common up the JS_DefineElement calls when there
          // are different ways to succeed at wrapping the object.
          do {
            if (!currentValue[sequenceIdx0].ToObjectInternal(cx, &tmp)) {
              return false;
            }
            break;
          } while (false);
          if (!JS_DefineElement(cx, returnArray, sequenceIdx0, tmp,
                                JSPROP_ENUMERATE)) {
            return false;
          }
        }
      }
      temp.setObject(*returnArray);
      if (!JS_DefinePropertyById(cx, obj, atomsCache->rectangles_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    JSObject* const & currentValue = mStack;
    if (currentValue) {
                  JS::ExposeObjectToActiveJS(currentValue);
                }
                temp.setObjectOrNull(currentValue);
    if (!MaybeWrapObjectOrNullValue(cx, &temp)) {
      return false;
    }
    if (!JS_DefinePropertyById(cx, obj, atomsCache->stack_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  do {
    // block for our 'break' successCode and scope for 'temp' and 'currentValue'
    JS::Rooted<JS::Value> temp(cx);
    double const & currentValue = mStart;
    temp.set(JS_NumberValue(double(currentValue)));
    if (!JS_DefinePropertyById(cx, obj, atomsCache->start_id, temp, JSPROP_ENUMERATE)) {
      return false;
    }
    break;
  } while(false);

  if (mType.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      nsString const & currentValue = mType.InternalValue();
      if (!xpc::NonVoidStringToJsval(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->type_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mUnixTime.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      uint64_t const & currentValue = mUnixTime.InternalValue();
      temp.set(JS_NumberValue(double(currentValue)));
      if (!JS_DefinePropertyById(cx, obj, atomsCache->unixTime_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  if (mWorkerOperation.WasPassed()) {
    do {
      // block for our 'break' successCode and scope for 'temp' and 'currentValue'
      JS::Rooted<JS::Value> temp(cx);
      ProfileTimelineWorkerOperationType const & currentValue = mWorkerOperation.InternalValue();
      if (!ToJSValue(cx, currentValue, &temp)) {
        return false;
      }
      if (!JS_DefinePropertyById(cx, obj, atomsCache->workerOperation_id, temp, JSPROP_ENUMERATE)) {
        return false;
      }
      break;
    } while(false);
  }

  return true;
}

void
ProfileTimelineMarker::TraceDictionary(JSTracer* trc)
{
  if (mEndStack) {
    JS::UnsafeTraceRoot(trc, &mEndStack, "ProfileTimelineMarker.mEndStack");
  }

  if (mStack) {
    JS::UnsafeTraceRoot(trc, &mStack, "ProfileTimelineMarker.mStack");
  }
}

namespace binding_detail {
} // namespace binding_detail


} // namespace dom
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53