/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/dom/SimpleGlobalObject.h"

#include "jsapi.h"
#include "js/Class.h"

#include "nsContentUtils.h"
#include "nsJSPrincipals.h"
#include "nsNullPrincipal.h"
#include "nsThreadUtils.h"

#include "xpcprivate.h"

namespace mozilla {
namespace dom {

NS_IMPL_CYCLE_COLLECTION_CLASS(SimpleGlobalObject)

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SimpleGlobalObject)
  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
  tmp->UnlinkHostObjectURIs();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(SimpleGlobalObject)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
  tmp->TraverseHostObjectURIs(cb);
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(SimpleGlobalObject)

NS_IMPL_CYCLE_COLLECTING_ADDREF(SimpleGlobalObject)
NS_IMPL_CYCLE_COLLECTING_RELEASE(SimpleGlobalObject)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SimpleGlobalObject)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
NS_INTERFACE_MAP_END

static void
SimpleGlobal_finalize(js::FreeOp *fop, JSObject *obj)
{
  SimpleGlobalObject* globalObject =
    static_cast<SimpleGlobalObject*>(JS_GetPrivate(obj));
  NS_RELEASE(globalObject);
}

static void
SimpleGlobal_moved(JSObject *obj, const JSObject *old)
{
  SimpleGlobalObject* globalObject =
    static_cast<SimpleGlobalObject*>(JS_GetPrivate(obj));
  globalObject->UpdateWrapper(obj, old);
}

static const js::ClassOps SimpleGlobalClassOps = {
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    JS_EnumerateStandardClasses,
    JS_ResolveStandardClass,
    JS_MayResolveStandardClass,
    SimpleGlobal_finalize,
    nullptr,
    nullptr,
    nullptr,
    JS_GlobalObjectTraceHook,
};

static const js::ClassExtension SimpleGlobalClassExtension = {
  nullptr,
  SimpleGlobal_moved
};

const js::Class SimpleGlobalClass = {
    "",
    JSCLASS_GLOBAL_FLAGS | JSCLASS_HAS_PRIVATE | JSCLASS_PRIVATE_IS_NSISUPPORTS,
    &SimpleGlobalClassOps,
    JS_NULL_CLASS_SPEC,
    &SimpleGlobalClassExtension,
    JS_NULL_OBJECT_OPS
};

// static
JSObject*
SimpleGlobalObject::Create(GlobalType globalType, JS::Handle<JS::Value> proto)
{
  JSContext* cx = nsContentUtils::GetDefaultJSContextForThread();
  JSAutoRequest ar(cx);

  JS::CompartmentOptions options;
  options.creationOptions().setInvisibleToDebugger(true);

  nsCOMPtr<nsIPrincipal> principal;
  if (NS_IsMainThread()) {
    principal = nsNullPrincipal::Create();
  }

  JS::Rooted<JSObject*> global(cx,
    JS_NewGlobalObject(cx, js::Jsvalify(&SimpleGlobalClass),
                       nsJSPrincipals::get(principal),
                       JS::DontFireOnNewGlobalHook, options));

  if (!global) {
    JS_ClearPendingException(cx);
    return nullptr;
  }

  JSAutoCompartment ac(cx, global);

  // It's important to create the nsIGlobalObject for our new global before we
  // start trying to wrap things like the prototype into its compartment,
  // because the wrap operation relies on the global having its nsIGlobalObject
  // already.
  RefPtr<SimpleGlobalObject> globalObject =
    new SimpleGlobalObject(global, globalType);

  // Pass on ownership of globalObject to |global|.
  JS_SetPrivate(global, globalObject.forget().take());

  if (proto.isObjectOrNull()) {
    JS::Rooted<JSObject*> protoObj(cx, proto.toObjectOrNull());
    if (!JS_WrapObject(cx, &protoObj)) {
      JS_ClearPendingException(cx);
      return nullptr;
    }

    if (!JS_SetPrototype(cx, global, protoObj)) {
      JS_ClearPendingException(cx);
      return nullptr;
    }
  } else if (!proto.isUndefined()) {
    // Bogus proto.
    return nullptr;
  }

  JS_FireOnNewGlobalObject(cx, global);
  return global;
}

// static
SimpleGlobalObject::GlobalType
SimpleGlobalObject::SimpleGlobalType(JSObject* obj)
{
  if (js::GetObjectClass(obj) != &SimpleGlobalClass) {
    return SimpleGlobalObject::GlobalType::NotSimpleGlobal;
  }

  SimpleGlobalObject* globalObject =
    static_cast<SimpleGlobalObject*>(JS_GetPrivate(obj));
  return globalObject->Type();
}

} // namespace mozilla
} // namespace dom